LIBRARY OF THE 
 
 UNIVERSITY OF ILLINOIS 
 
 AT URBANA-CHAMPAIGN 
 
 «aoA*3-444 
 
l« es , Date staApX,"™ " bef ° re the 
 
 £^r;-.r rsv.-r • 
 
 rt-e University. mqy re »>" in dismissal f rom 
 
 ^S^lJ^NOIS HBRARY AT UR8AN4 r 
 
 L161— O-1096 
 
Digitized by the Internet Archive 
 in 2013 
 
 http://archive.org/details/weedwonderfulequ444fraz 
 
/O- * r 
 
 ~ta / Report No. khk 
 
 ■J L- a- 
 
 /Tl'LtJ, 
 
 COO-1U69-0181 
 
 WEED 
 A WONDERFUL EQUATION ELIMINATION DEVICE 
 
 by 
 
 CELSO JOHN FRAZAO GUIMARAES 
 
 June 1971 
 
Report No. UUU 
 
 WEED 
 A WONDERFUL EQUATION ELIMINATION DEVICE* 
 
 by 
 
 CELSO JOHN FRAZAO GUIMARAES 
 
 June 1971 
 
 Department of Computer Science 
 University of Illinois 
 Urbana, Illinois 6l801 
 
 This report vas supported in part by the Department of Computer 
 Science and in part by the Atomic Energy Commission under grant 
 US AEC AT( ll-l)lU69» and submitted to the graduate college in 
 partial fulfillment of the requirements for the degree of Master 
 of Science in Computer Science. 
 
ERRATA TO 
 
 REPORT NO. khk COO-lU69-Ol8l 
 
 WEED 
 A WONDERFUL EQUATION ELIMINATION DEVICE 
 
 by 
 
 CELSO JOHN FRAZAO GUIMARAES 
 June 1971 
 
 List of Corrections 
 
 p. U, line 3 
 
 I ± = I *sin( *T) should be I = I *sin(7T*T; 
 
 p. 18, line 5 
 
 E C = should be E *C = 
 
 p. 18, line 6 
 
 C E = should be C*E = 
 
 p. 18, line 7 
 
 E E = should be E 1 **E 2 = 
 
 p. 18, line 8 
 
 E +E = should be E +E = 
 
 p. 18, line 8 
 
 -E should be +E 
 
 p. 18, line 9 
 
 E E should be E *E 
 
 p. 18, line 10 
 
 E 2 E should be E 2 *E 3 
 
p. 18, line 11 
 
 
 E E, = E E should be E *E^ = E *E 
 
 p. 19, lines 15, 19, and 21 
 
 Change the 5.3's and 5.1 to 6.3's and 6.1, 
 
 p. 22, line 7 
 
 or '1' should be or '-!' 
 

Ill 
 ACKNOWLEDGMENT 
 I am indebted to the following people whose assistance was 
 most invaluable in the preparation of this thesis. To Professor C. W. Gear 
 for suggesting the topic and for his enlightening guidance in times of 
 panic. To Miss Barbara Hurdle for her unmatched patience and talent in 
 typing the manuscript. To the Graphics Group (Al Whaley, Marty Michel, 
 Roger Haskin, John Nickolls, and Sally Wilkins) for the fruitful "rap" 
 sessions. And to the Department of Computer Science in general for so 
 kindly providing all the necessary facilities. 
 
IV 
 
 PREFACE 
 
 This thesis is a description of WEED, an algorithm r 
 simplifying systems of equations symbolically and classifying variables 
 
 r further numerical >. It J iphics- 
 
 Oriented Simulation and I-bdeling System currently being developed at the 
 University of Illinois. 
 
 Through a consistent method of elimination, WEED produces a 
 condensed system of equations and an Equivalence Table for variables, 
 which allow for a more efficient compilation and numerical integration 
 than would otherwise be possible. 
 
V 
 
 TABLE OF CONTENTS 
 
 Page 
 
 1. THE MODELING SYSTEM 1 
 
 2. PK. ARIES AND OVERVIEW OF THE ALGORITHM 3 
 
 3. INPUT SPECIFICATIONS 6 
 
 k. OUTPUT REQUIREMENTS 10 
 
 5. EQUATION CLASSIFICATION Ik 
 
 5.1 Variable = Constant 16 
 
 5.2 Variable = Variable ( - 
 
 5.3 Variable = Expression IT 
 
 5.U Expression = Expression 18 
 
 6. THE PROCESS ROUTINE 19 
 
 6.1 Constant 19 
 
 6.2 Global Variable or TIME 19 
 
 6.3 Other Variable 19 
 
 6.U Binary Operation 20 
 
 6.5 Unary Operation 22 
 
 6.6 User-Defined Function 23 
 
 7. THE FINAL STAGES: NAME REASSIGNMENTS , 
 
 EQUATION RESTRUCTURING AND OUTPUT 2k 
 
 BIBLIOGRAPHY 26 
 
 APPENDICES 27 
 
1 
 
 1. THE MODI. YSTEM 
 
 The Geno Lon and Modeling System currently being 
 
 developed at the University of Illinois has as its primary objective 
 "to pr a tool which he can (graphically) 
 
 construct models of a proposed system and analyze them for static, 
 dynamic and oscillatory behavior. The user will have the capability 
 to define elements which are models of individual items of his system 
 (e.g. diodes, motors, water pumps) and specify their behavior by means 
 of differential and algebraic equations. The elements will have 
 terminals (e.g. wires, mechanical links, pipes) through which certain 
 variables may be transmitted (e.g. voltage, current, torque, displacement, 
 pressure, flow). The terminals from several elements can be connected 
 together at nodes (connection points) to form a network . " A network 
 may be used as an element of a larger network, and hence in a recursive 
 fashion fairly complex networks can be constructed quite easily. The 
 overall network is then the model of the proposed system, and is equivalent 
 to the system of differential and algebraic equations derived from each 
 element and node of the model. Thus the model can be completely analyzed 
 by solving this equivalent system of equations. 
 
 The user interacts with the Modeling System through a drawing 
 program which builds data structures representing each element and 
 network. From these, Item and Global Analyses create new data structures 
 which no longer contain graphical information. The equations are parsed 
 into tree structures, assigned values are substituted in the equations, 
 and all external names are replaced with new internal pointers. WEED 
 then simplifies the equations, classifies them according to the types of 
 operations and variables they contain, and weeds out those which are no 
 
2 
 
 longer needed. Variables are organized in an Equivalence Table according 
 to their original definition, and placed into different sets depending on 
 how they are used in the equations. New internal names are then assigned 
 to all the variables, and *„he equations are updated and restructured into 
 a compact format. The final stage then compiles the condensed system of 
 equations, and solves for transient, steady-state or oscillatory response. 
 
3 
 
 2. PRELIMINARIES AND OVERVIEW OF TOE ALGORITHM 
 Variables contained in the system of equations are not all of 
 the same nature. Some refer to terminals in the network, and are 
 identified as I -variables (e.g. electrical current). Others are 
 associated with nodes and are classed as E-variables (e.g. voltage). 
 iOcai variables (also called internal variables) are those which are 
 specific to an instance of element in the network. Global variables , 
 on the other hand, are common to groups of elements (e.g. ambient 
 temperature). The special global variable TIME is permanently assigned. 
 Finally, parameters are those variables associated with a given type of 
 element, whose value is specified with each instance of that element in 
 the network (e.g. resistance of a resistor). 
 
 In addition to keeping track of the above categories, WEED 
 places all variables into four mutually exclusive sets , according to 
 their usage in the equations : 
 
 a. Set S — all global variables and variables defined by S - 
 equations (of the form V = function (globals and 
 constants only)). 
 
 b. Set S„ — variables defined by S -equations (of the form 
 V = function (globals, constants, and time)), and the 
 special variable TIME. 
 
 c. Set L — variables involved only in linear expressions. 
 
 d. Set M — variables involved in non-linear or differential 
 expressions. As an example, given the equations 
 
E Q = 3*E 1 * G *(E 2 +E 3 ) - 1/E^ + (E 5 +2)»T - E g «E +££ 
 
 h " 3 - V 2 
 l x = I *sin( *T) 
 
 h - <V 3)/<I lV 
 
 where the E. are E-variables, the I. are I -variables , the G. are globals 
 111 
 
 and T is tine, E through E would belong in set L; E, through Eo in set 
 M; I in set S ; and I and I in set S . Note that since global values 
 are fixed throughout any given execution of the Modeling System, global 
 variables are treated as constants insofar as variable and expression 
 classification is concerned. 
 
 An additional set DY of new variables is created for the 
 output of general equations, and is discussed in section h. 
 
 A number of passes are made through the system of equations, 
 each time advantage being taken of simplifications made in previous 
 passes. As each equation is processed, all expressions which are only 
 functions of constants are evaluated immediately and replaced by the 
 result. Expressions of the form 
 
 E+0, 0+E, E*0, 0*/E, E*/l, 1*E, E**0, E**l, 
 
 1**E, and — (S., or S -expression) 
 at l d 
 
 are simplified as they are detected, and unary minuses are eliminated 
 
 wherever possible. Equations which become trivial relations, such as 
 
 variable = constant 
 or 
 
 variable = +_ variable 
 are eliminated by setting appropriate pointers in the Equivalence Table 
 (described in section U), and the remaining equations are placed 
 
into three sets: S -equations, S -equations, and general equations 
 (those which are neither S nor S ). 
 
 The reason for arranging all the equations and variables 
 into different sets is that each set can receive special treatment in 
 the numerical analysis phase, thereby increasing performance and 
 reducing cost. For instance, variables in set S need only be evaluated 
 once per simulation; those in set S p once per time step; and derivatives 
 of variables in set L need not be evaluated at all. 
 
 The equations are reprocessed until there are no more changes 
 in the Equivalence Table (up to a maximum of three passes). All 
 variables are then renumbered so that the members of each set are 
 
 contiguous in memory — that is, the numbers to n -1 refer to the n 
 
 S l S l 
 
 members of set S ; n to n + n -1 to the n members of set S ; 
 1 S 1 S 1 b 2 b 2 2 
 
 n + n to n + n + n -1 to the n members of set L; and n + n 
 S l S 2 S l S 2 L L S l b 2 
 
 + n ton +n +n T + n, -1 to the n„ members of set M. The new 
 
 L S S L M M 
 
 names are substituted in the equations, and these in turn are compressed 
 and output in their three different sets to the numerical integration 
 routines. A concise flow chart of the WEED algorithm is given in 
 Appendix A. 
 
3. INPUT SPECIFICATIONS 
 The input to WEED consists of a set of Input Tables and 
 a single list of equations, as shown in Figure 1. 
 
 fullvord- 
 
 - ptr. const, table 
 
 L' all Input 
 
 ptr. equation list 
 
 # E-variables 
 
 # I-variables 
 
 ptr. next avail, 
 location In 
 const, table 
 
 ptr. internal var. 
 name table 
 
 ptr. next avail, 
 loc. In variable 
 name table 
 
 ptr. global 
 name table 
 
 ptr. next avail, 
 location In global 
 name table 
 
 ptr. parameter 
 name table 
 
 ptr. next avail. 
 
 par 
 
 am. name table 
 
 D'O' 
 
 D'l' 
 
 D'-l' 
 
 CONSTANT TABLE 
 
 ptr. next equation 
 
 Equation 1 
 
 ptr. next equation 
 
 Equation 2 
 
 INTERNAL VARIABLE 
 NAME TABLE 
 
 GLOBAL 
 NAME TABLE 
 
 
 PARAMETER 
 NAME TABLE 
 
 • All pointers in Table 
 displacements from 
 this location 
 
 doubleword ■ 
 
 Figure 1. Input to WEED 
 
7 
 The Name Tables contain the actual eight-character variable 
 names provided by the user. In the equations, however, these variables 
 are represented by the displacement of their name from the beginning 
 of their respective Name Tables. The same holds true for constants, 
 where the Constant Table contains the double-precision floating-point 
 constant values. 
 
 The equations are in tree-structured form, and consist of a 
 series of "nodes" of information connected by pointers, as illustrated 
 in Figure 2. The first node of each equation consists of a pointer to 
 the next equation in the list, as a displacement from the current 
 
 equation. The remaining nodes are clusters of halfwords (usually two 
 
 2 
 or three) contiguous in memory. The first HW of each node is an op-code 
 
 which indicates the type of node. If the node represents an operation, 
 
 3 
 
 the remaining HW- fields contain pointers to its respective operands. 
 
 If the node is a variable or constant, the second HW contains the 
 internal name associated with it. Table 1 describes the different op- 
 codes and associated operands. 
 
 E- and I-type variables do not have alphameric names associated with 
 them, and are numbered sequentially, starting from 0. 
 
 2 
 
 The 'user-specified function' node is a variable-length node, 
 
 including fields for function type (second HW) and number of 
 
 pointers (third HW). 
 
 3 
 
 A 'function' node contains a field specifying the type of function 
 
 (second HW). 
 
28 
 
 
 u 
 
 o 
 
 8 
 
 
 A 
 
 
 \ 
 
 6 
 
 8 
 
 
 12 
 
 
 
 ■*• 
 
 i 1 
 
 
 = 
 
 J^ 
 
 
 5 
 
 ) 
 
 
 A 4 
 
 
 C 
 
 E | 10 
 
 
 
 
 
 f 
 
 3 f 10 
 
 
 \ i 
 
 
 1 1 - 1 v 1 
 
 1 
 
 
 
 
 
 1 
 
 ♦ 1- 
 
 
 
 
 
 12 x'lU 16 
 
 1 
 
 
 
 
 l^ 
 
 L6 
 
 18* 20 
 
 
 1 misinj^ 
 
 
 1 5 
 
 1 
 
 L 
 
 i S | 
 
 
 18 ^"Ia ic 
 
 
 
 i 3 = i +Gl 
 
 
 
 
 1 *>• | 
 
 1 
 
 
 
 IE **£o 22* 
 
 2U 
 
 
 
 1 2 
 
 n 
 
 
 
 E o = " 
 
 sin(P *T) 
 
 
 
 address 
 
 in memory 
 
 
 
 0000 
 
 0028 
 
 i 
 
 h 
 
 0007 
 
 000A 
 
 00 OE 
 
 A 
 
 000U 
 
 0000 
 
 
 E 
 
 0011 
 
 0012 
 
 
 12 
 
 0012 
 
 0006 
 
 0018 
 
 18 
 
 000A 
 
 001E 
 
 0022 
 
 IE 
 
 0002 
 
 0008 
 
 
 22 
 
 0000 
 
 0000 
 
 
 28 
 
 0000 
 
 002H 
 
 
 2C 
 
 0007 
 
 000A 
 
 OOOE 
 
 32 
 
 0005 
 
 0003 
 
 
 36 
 
 0008 
 
 OOlU 
 
 0018 
 
 3C 
 
 0006 
 
 0008 
 
 
 UO 
 
 0001 
 
 0008 
 
 _ 
 
 Figure 2. Equation Format 
 
■•- ' 
 
 0p_ 
 
 Time 
 
 X ' 1 1 ' 
 
 Global Variable 
 
 1 
 
 Parameter 
 
 2 
 
 Internal Variable 
 
 3 
 
 E-Variable 
 
 It 
 
 I -Variable 
 
 5 
 
 Constant 
 
 6 
 
 Equals (=) 
 
 7 
 
 Addition (+) 
 
 8 
 
 Subtraction (-) 
 
 9 
 
 Multiplication ( *) 
 
 A 
 
 Division (/) 
 
 B 
 
 Assignment (-«- ) 
 
 C 
 
 Power ( **) 
 
 D 
 
 Max 
 
 E 
 
 Min 
 
 F 
 
 Differentiation 
 
 10 
 
 Unary 
 
 11 
 
 Function 
 
 12 
 
 User-spec fn 
 
 13 
 
 Table 1. 
 
 Int 
 
 Operands Halfwords 
 
 X'0 f 2 
 
 Displ. in Global Name Table 2 
 
 Displ. in Parm Name Table 2 
 
 Displ. in Int. Var. Name Table 2 
 
 Numeric Name 2 
 
 Numeric Name 2 
 
 Displ. in Constant Table 2 
 
 Left-pointer; Right-pointer 3 
 
 L-ptr; R-ptr 3 
 
 L-ptr; R-ptr 3 
 
 L-ptr; R-ptr 3 
 
 L-ptr; R-ptr 3 
 
 L-ptr ; R-ptr 3 
 
 L-ptr; R-ptr 3 
 
 L-ptr; R-ptr 3 
 
 L-ptr; R-ptr 3 
 
 Operand-ptr 2 
 
 Operand-ptr 2 
 
 Fn ID#; Operand-ptr 3 
 Fn ID# ; /^-operands ;operand-ptrs >_ 3 
 
 Internal Codes for Equation Nodes 
 
10 
 • • OUTPUT REQUIREMENTS 
 The output consists of a Table Block and an Equation Block, 
 iepicted Li ; ;re 3. The Table Block consists of the Constant 
 Tab. ig possl- litions create: - le WEED step), the input 
 
 • use i. 3-referencing and diagnostics), and the 
 . le (E'v, . ich contains all the variables ordered 
 according to network type, with their respective new internal names 
 (variables found to be equivalent will, of course, have the same assigned 
 name). The Table Block also contains other necessary data, such as 
 rs to the various tables and to the Equation Block. 
 
 Upon entry to WEED, the variables are arranged in the EQV in 
 order of ascending numeric names for each field in the table, as shown 
 in Figure k. As the equations are processed, different types are 
 assigned to the variables, and appropriate pointers are set for those 
 which are found to be equivalent to other variables or to constants. 
 During internal name reassignment, all variables are marked 'assigned' 
 (except for those equivalent to constants), so that upon output, only 
 three types will be present in the EQV: assigned (+V), assigned (-V), 
 and constants. 
 
11 
 
12 
 
 TYPICAL CONFIGURATION 
 TYPE VALUE 
 
 
 
 EQV TYPE 
 
 
 REPRESENTATION 
 1st HW 2nd HW 
 
 
 
 Unused 
 
 
 X'OO' 
 
 x'00' 
 
 
 
 s i 
 
 
 01 
 
 00 
 
 
 
 : 2 
 
 
 02 
 
 00 
 
 
 
 L 
 
 
 03 
 
 00 
 
 
 
 M 
 
 
 oU 
 
 00 
 
 Displ. 
 Const. 
 
 in 
 Table 
 
 Assigned ( 
 Assigned ( 
 
 +v) 
 
 -v) 
 
 Al 
 AF 
 
 new name 
 new name 
 
 
 
 Constant 
 
 
 CI 
 
 pointer to 
 const, table 
 
 
 
 + Variable 
 
 
 Fl 
 
 ptr. to var 
 in EQV 
 
 Displ. 
 
 in 
 Table 
 
 -Variable 
 
 
 FF 
 
 ptr. to var 
 in EQV 
 
 GL0BALS ( 
 
 nsra 
 
 VARIABLES 
 
 parameters/ 
 
 - 
 
 I-VARS 
 
 <« .alfword-*.-«Halfword-». 
 
 Figure k. Equivalence Table 
 The Equation Block consists of three sub-blocks corresponding 
 to the three different sets of equations. The equations take a form 
 similar to the input equations, with two differences: 
 
 1. Operation nodes incorporate operands which are variables, 
 their pointer fields being replaced by the corresponding 
 new variable names. The remaining pointers to other nodes 
 take on a negative value, in order to differentiate from 
 variable names. 
 
13 
 General equations are put in the form = expression, 
 and the is replaced by a new variable of the set DY, 
 
 where the DY's are numbered starting at n c + n^ + n + n 
 
 S l S 2 L 
 
 . -gure 5 illustrates the modifications performed on the 
 example of Figure 2. 
 
 M" 
 
 
 '6 B 
 
 = 
 
 l DYfji^« | 
 
 A ^ 
 
 ^C E 
 
 + 
 
 1 En 1^- 1 
 
 10 * 
 
 Sfr lU 
 
 p. 
 
 1 sin /• | 
 
 16 * 
 
 -l8 1A 
 
 1 * 
 
 IP-.IT 
 
 j next 
 general 
 equation 
 
 DY = E + sin(P *T) 
 
 A 
 
 next 
 
 S -equation 
 
 I G-i | 
 
 10* 12 
 
 I 6 | 8 | 
 
 I. = 1 + G. 
 
 Address In Memory 
 
 0000 001C 
 
 k 0007 0123 FFF6 
 
 A 0008 0069 FFF0 
 
 10 0012 0006 FFEA 
 
 16 000A 0033 0017 
 
 ASSUMING 
 var new name 
 
 DY o 
 
 123 
 
 E o 
 
 69 
 
 p l 
 
 33 
 
 T 
 
 17 
 
 X 3 
 
 269 
 
 G l 
 
 1 
 
 Address 
 
 
 
 h 
 
 A 
 
 10 
 
 In Memory 
 0000 001^ 
 
 0007 0269 fff6 
 
 0008 FFF0 0001 
 0006 0008 
 
 Figure 5- Output Equations 
 
Ill 
 
 >. EQUATION CLASSIFICATION 
 
 For this and the following sections, the flow charts provided 
 in the Appendices should be useful as an aid to understanding the 
 ..m. 
 
 Upon entry, 3 goes through an initialization phase, in which 
 s an area for the output Table Block, copies the Name Tables 
 and Constant Table from the input area, sets pointers to the different 
 tables, and zeroes out the Equivalence Table. It is then ready for the 
 Equation Classification stage. 
 
 WEED takes each equation in turn, replaces the '=' in the first 
 node by a '-', and calls upon the PROCESS Routine (described in section 6 ) 
 to determine the types of expressions on the left and righthand sides 
 of the equation. PROCESS travels recursively down the tree, performing 
 simplifications as it goes along, and returns two pairs of numbers 
 representing the left and right expression types. Every expression has 
 two numbers associated with it: one (referred to in the program as EXPTP, 
 LX or RX) which gives an indication of the structure and complexity of 
 the expression; and another (referred to as S1S2EXP, S1S2LX, or S1S2RX) 
 which indicates whether the expression is type S , S , or neither. 
 Table 2 lists the possible types and respective codes. 
 
15 
 
 (EXPTP, LX, RX) (S1S2EXP, S1S2LX, S1S2RX) 
 
 constant '0* (S1S2EXP=1) Neither S nor S -expression 
 
 1 other constant =l) 1 ression (single consts. included) 
 single variable 2 S -expression 
 
 3 constant +_ variable 
 h variable + variable 
 5 general expression 
 
 Table 2. Expression Types 
 
 Once WEED receives the left and right expression types from 
 PROCESS, it restores the '=' and tries to put the equation in a standard 
 format, according to the following priorities: 
 
 1. S or S -expressions on the right side. (if the left 
 side is also an S or S -expression an error is indicated, 
 the equation is eliminated and the next equation is fetched. ) 
 
 2. Single variable on the left side. 
 
 3. Doublet (C+V or +V +V) on the left side. 
 
 After the appropriate switches are made, if a doublet (or any 
 expression of the form E+E) is found on the left, it is split up, the 
 left branch of the doublet being transposed to the right side of the 
 equation. At this stage, the equation will necessarily be in one of 
 the following forms : 
 
 Any constants in a doublet are always kept on the left. Hence in a 
 split-up, the constant always gets moved to the right side of the equation, 
 
Lable = + ole 
 variable = expresc i 
 - 
 We scribe th . each case. 
 
 5-1 Variable = Const 
 
 Set variable type to 'constant' (X'Cl') in the EQV. Place 
 a pointer to the constant (as a displacement from the beginning of the 
 Constant Table) in the EQV value field of the variable. Eliminate the 
 equation, and set to 1, indicating a change made to the EQV. 
 
 p. 2 Variable = Variable 
 
 The two variable types determine the action to be taken, 
 according to the following table: 
 
 Variable^ 
 
 Variable 
 
 - 
 
 L 
 
 C 
 + 7 
 
 S l S 2 L 
 
 
 +V -V 
 
 E 
 
 E 
 
 £ 
 
 -*• 
 
 E 
 1 
 
 _3k 
 
 _^ 
 
 E 
 
 E 
 
 ^- 
 
 ^- 
 
 i 
 
 1 
 
 E 1 
 
 1 
 
 
 T— 
 
 OK 
 
 OK 
 
 OK 
 
 OK 
 
 ok| 
 
 OK 
 
 OK 
 
 OK 
 
 OK 
 
 — 
 
 OK 
 
 OK 
 
 OK 
 
 OK 
 
 
 E 
 
 ~1- 
 
 _i 
 
 E 1 
 
 I 
 
 
 — 
 
 "> 
 
 ^ 
 
 ~^- 
 
 
 N 
 
 ^ 
 
 ^ 
 
 . 
 
 '% 
 
 i- 
 
 _i 
 
 "> j 
 
 _ 
 
 ♦ ' 
 
IT 
 E: Error. Relay message to the user and delete the equation. 
 4^: Switch the variables, so that variable becomes variable 
 
 and vice versa. Refer to the table. 
 
 2 
 ^ : Follow the pointer (or chain of pc ■ ;) beginning at 
 
 ■iable, . The last variable in the chain becomes the 
 
 new variable . Return to the table. 
 
 OK: Set the type of variable to +V or -V according to the 
 
 equation which defines it. If variable,, points to another 
 
 d. 
 
 2 
 variable, follow the pointer chain. Place a pointer to 
 
 3 
 the new variable in the value field of variable . 
 
 Eliminate the equation and set EQVFLAG to 1. 
 
 5 . 3 Variable = Expression 
 
 If the expression is neither a S-nor S -expression, go to 
 section 5.*+ (Expression = Expression). Set the variable type to S 
 or S accordingly. If the equation has already been placed in the 
 proper equation set, proceed to the next equation. Otherwise, mark 
 
 : equation by placing a 1 or 2 in the first byte of its link field, 
 and set EQVFLAG to 1. 
 
 . order to avoid following long chains in future searches through 
 the EQV, a direct pointer is set from the variable being traced to 
 the last variable in the chain. 
 
 - 
 
 - . the case where variable^ points to a cor.. * n1 , variable is made 
 
 to point to the same constant (or its complement) and its type is 
 set to 'constant.' 
 
18 
 j . k expression = Expression 
 
 If the equation is in any of the following forms, simplify 
 it, retest it for further simplifications and reprocess it: 
 
 V E 2 " 
 
 
 
 -> 
 
 E l 
 
 — 
 
 
 
 
 E X C = 
 
 
 
 -> 
 
 E l 
 
 = 
 
 
 
 for C 4 
 
 CE 1 * 
 
 
 
 ->■ 
 
 E l 
 
 = 
 
 
 
 for C i 
 
 E l V 
 
 
 
 -> 
 
 E l 
 
 = 
 
 
 
 
 E li E 2 = 
 
 °3 
 
 -> 
 
 E l 
 
 = 
 
 " E 2 
 
 
 E l /E 2 = 
 
 E 3 
 
 ->■ 
 
 E l 
 
 = 
 
 E 2 E 3 
 
 
 E 3 * 
 
 E l /E 2 
 
 ->■ 
 
 E l 
 
 = 
 
 E 2 E 3 
 
 
 E l /E 2 " E 3 /E ^ " E l \- E 2 E 3 
 
 If from the first test it is found that the equation fits none 
 of the above categories, place it in the set of general equations (by 
 putting a 3 in the first byte of its link field) and proceed to the 
 next equation. 
 
19 
 6. THE PROCESS ROUTINE 
 
 Given a pointer to the top node of an expression, PROCESS will 
 simplify the expression and determine its type. The types of lower level 
 expressions (i.e. operand expressions) are used in determining the type 
 of the current expression. Thus pairs of numbers (EXPTP ,S1S2EXP) 
 representing each lower level expression are transmitted recursively, 
 from the bottom up. 
 
 The top node of each expression determines the subsequent 
 steps to be taken, as follows: 
 
 6 .1 .. -. ;.-. 
 
 Determine whether the constant is zero or non-zero, and set 
 EXPTP to or 1 accordingly. Set S1S2EXP to 1. Return. 
 
 6.2 Global Variable or TIME 
 
 Set EQV type to S if node is a global, or to S if it is 
 TIME. Go to 5.3. 
 
 6 . 3 Other Variable 
 
 If unused so far, make the variable type L. If type L or M, 
 set S1S2EXP to 0. If type S or S set S1S2EXP to 1 or 2, respectively. 
 If type +V or -V, follow pointer chain and repeat 5.3. If type 
 'constant,' replace node in tree with a corresponding constant node, and 
 go to 5.1. Set EXPTP to 2 (single variable) and return. 
 
20 
 
 Binary Operation 
 
 Process the left and right expressions, remembering their 
 respective types. S1S2EXP for the current expression is determined 
 from the following table : 
 
 S1S2RX (right) 
 
 S1S2EXP 
 
 
 
 1 
 
 2 
 
 
 
 
 
 
 
 
 
 1 
 
 
 
 1 
 
 2 
 
 2 
 
 
 
 2 
 
 2 
 
 S1S2LX 
 (left) 
 
 Simplify unary minuses according to the rules of algebra, placing any 
 remaining unary minus above the current node (in most cases, unary minuses 
 can be successively bubbled up in this manner, so that upon reaching 
 the top of the equation at most one unary minus remains). 
 
 If the operation is addition or subtraction , eliminate any 
 zeros on either side of the expression. Add or subtract constants 
 appearing in constant nodes or doublet expressions (C+V), keeping the 
 resultant constant on the left branch (either of the current node or 
 of the left doublet). Determine EXPTP from the left and right expression 
 types according to the table below, and return. 
 
 1 
 
 If the top node of the equation is being processed (with ' = ' replaced 
 by '-♦) zeros are preserved. 
 
21 
 
 RX 
 
 DC 
 
 EXPTP 
 (+/-) 
 
 
 
 1 
 
 2 
 
 3 
 
 1* 
 
 5 
 
 
 
 
 
 
 1 
 
 2 
 
 3 
 
 It 
 
 5 
 
 1 
 
 1 
 
 1 
 
 3 
 
 3 
 
 5 
 
 5 
 
 2 
 
 2 
 
 "3 
 
 i 
 
 *5 
 
 5 
 
 
 3 
 
 3 
 
 3 
 
 5 
 
 5 
 
 5 
 
 5 
 
 U 
 
 it 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 If the operation is multiplication or division , eliminate any 
 
 l's or -l's on either side of the expression. If either side is 0, make 
 
 2 
 the current node a 0. If both sides are constants, evaluate the 
 
 expression. From S1S2LX and S1S2RX determine whether the expression is 
 
 non-linear under multiplication or division, as follows: 
 
 S1S2RX 
 
 CALL 
 NONLIN 
 
 2 
 
 
 
 *,/ •■/ 
 
 1 
 
 / 
 
 2 
 
 *,/ 
 
 S1S2LX 
 
 If it is non-linear, call NONLIN (a routine which sets all L-type variables 
 in the subtree to M-type and marks the top node of the expression as 
 non-linear by making its op-code negative. This way, if a higher level 
 expression is also found to be non-linear, the present subtree will not 
 have to be rescanned) . Finally, determine EXPTP from the table below, 
 and return. 
 
 Division by zero causes an error message and automatic elimination of 
 the equation. 
 
22 
 
 RX 
 
 LX 
 
 EXPTP 
 
 
 
 1 
 
 o 
 
 ■ -- ■ i 
 3 
 
 k 
 
 5 
 
 (*,/) 
 
 •1' 
 
 or '-1' 
 
 other 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 1 
 
 '1* 
 or '1' 
 
 u 
 
 ]_ 
 
 1 
 
 2 
 
 3 
 
 1+ 
 
 5 
 
 other 
 
 
 
 1 
 
 1 
 
 5 
 
 5 
 
 5 
 
 5 
 
 2 
 
 
 
 2 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 3 
 
 
 
 3 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 U 
 
 Q 
 
 It 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 5 
 
 For the case of a power operation, if both operands are 
 constants, perform the exponentiation (C **C evaluated as e ^ l) s 
 and set EXPTP to or 1 depending on the result. Perform the following 
 simplifications if possible: 
 
 E**0 -»■ 1 (EXPTP <- 1) 
 
 E**l ■> E (EXPTP *■ LX) 
 
 0**E + (EXPTP «- 0) 
 
 1**E ■+ 1 (EXPTP ♦■ 1) 
 If no simplification is possible, call NONLIN and set EXPTP to 5 
 (general expression). Return. 
 
 If the operation is max or min evaluate the expression if 
 both operands are constants. Otherwise, call NONLIN and make 
 EXPTP = 5- Return. 
 
 6 .5 Unary Operation 
 
 Process the left operand. S1S2EXP is passed from operand to 
 operator unchanged (i.e. 31S2EXP «- S1S2LX) . 
 
23 
 If the operation is differentiation , move any unary minus 
 upwards. If the operand is an S -expression, replace the current 
 expression with the constant '0' and set EXPTP to 0. Otherwise, 
 call NONLIN and make EXPTP = 5. Return. 
 
 For a unary minus operation, if the operand starts with a 
 unary minus, delete both unary minuses. If the operand is a 
 constant, complement it and delete the unary minus. Copy EXPTP from 
 the operand (i.e. EXPTP «- LX) and return. 
 
 If the operation is function , evaluate it if the operand is 
 a constant, replacing the expression with the result, and setting 
 EXPTP to or 1. Otherwise, call NONLIN and set EXPTP to 5. Return. 
 
 6.6 User-Defined Function 
 
 Process all the operand subexpressions, call NONLIN, set 
 S1S2EXP to and EXPTP to 5- Return. 
 
2k 
 
 1. THE FINAL STAGES: NAME REASSIGNMENTS , 
 EQUATION RESTRUCTURING AND OUTPUT 
 
 Having processed the entire system of equations, WEED counts 
 the numbers of independent S , S , L and M variables in the EQV and 
 
 --.ializes each of four registers with the first numeric name to be 
 assigned to variables in each of the four sets. As the EQV is scanned, 
 each time a new variable is encountered its value field is overwritten 
 with the contents of its associated register, its type set to ' assigned(+V) 
 and the register incremented by 1. Whenever a variable type +V or -V is 
 encountered, the new name of its equivalent variable is copied in its 
 value field, and its type set to ' assigned(+V) ' or 'assigned(-V) ' , 
 accordingly. 'Constant' type variables remain unchanged. As a final 
 result, all variables will have been numbered sequentially, with all 
 S -variables first, S_-variables next, and so on. 
 
 At this point, the equations are modified so that the new 
 variable names are contained within operation nodes. As the equations 
 are processed, a cumulative byte count is kept for each of the three 
 equation sets , so that an appropriate amount of core can be later 
 requested for the output Equation Block. Each tree is traversed 
 recursively by means of the TRAVEL Routine (MODFORM mode). As each 
 variable is detected, it is incorporated in its parent node by over- 
 writing the respective pointer field. An exception if made for the 
 case where the variable is ' assigned(-V) ' , in which case the old variable 
 is transformed into a unary- node whose operand field contains the new 
 variable name. Constants are not incorporated in parent nodes, and all 
 remaining node-pointer values are made negative. 
 
25 
 Once all the equations have been reformatted, WEED issues 
 a GETMAIN for the output Equation Block and calls upon the PUTOUT 
 Routine to supervise the output operation. PUTOUT looks only at S - 
 equations to begin with, and passes them one by one to TRAVEL (TRANSFER 
 mode), which recursively moves individual nodes to consecutive memory 
 locations in the output area. Since the equations are squeezed into a 
 compact form, the displacement relationships between the nodes are 
 altered, and hence new pointer values must be set as the nodes are 
 moved. New link pointers to the next equation can be set as soon as each 
 equation transfer is completed. 
 
 PUTOUT repeats this process for S and General Equations, and 
 returns to WEED after setting pointers to the three sets of equations 
 in the Table Block. Finally, the entire input area is FREEMAINed, the 
 compiler is called, and WE ARE DONE. 
 
26 
 
 BIBLIOGRAPHY 
 
 Gear, C. W. , Hyde, C. , Levin, H. , Michel, M. J., Ratliff, K. , 
 
 and Wilkins , S., "The Simulation and Modeling System — 
 
 A Snapshot View," Department of Computer Science File No. 82U, 
 
 University of Illinois, Urbana, Illinois (1970). 
 
 .■stem/360 Operating System: Assembler Language," IBM Systems 
 Reference Library File No. S360-21 form GC28-651U-6. 
 
 "IBM System/360 Operating System: Linkage Editor," IBM Systems 
 Reference Library File No. S360-31 form C28-6538-6. 
 
 "IBM System/360 Operating System: Supervisor and Data Management 
 Macro Instructions," IBM Systems Reference Library File 
 No. S360-36 form GC28-66U7-3. 
 
27 
 
 APPENDICES 
 
28 
 
 I 
 
 GIT SPACE TOR OUTPUT 
 TABLE BLOCK, COPY 
 CONSTANT I NAME TABLES, 
 3ET POINTERS , ZERO OUT 
 EQUIVALENCE TABLE 
 CYCLES - 
 
 CYCLES * CYCLES ♦ 1 
 
 EQVTLAG - 
 
 GET INPUT EQUATION PTR 
 
 GET NEXT EQUATION, 
 CLASSIFY IT OR 
 
 ELIMINATE IT 
 
 EQVFLAG - 1 
 
 SCAN EQV AND COUNT 
 
 #S1, S2, L1H VARS 
 ASSIGN NEV 
 
 INTERNAL NAMES 
 
 SUBSTITUTE VARIABLE 
 
 NAMES IN ALL EQUATIONS 
 
 k MODIFY FORMAT 
 
 FOR OUTPUT 
 
 GET SPACE FOR OUTPUT 
 EQUATION BLOCK. MOVE 
 31-EQHS to SI BLOCK 
 S2-EQNS TO S2 BLOCK 
 GEN EQNS TO GEN BLOCK 
 SET PTRS IN TABLE BLOCK 
 FREEMAIN INPUT AREA 
 
 SET ALL SI i S2 VARS 
 (EXCEPT GLOBALS i TIME) 
 AND ALL M VARIABLES TO 
 TYPE L IN EQV 
 
 Y 
 
 N 
 
 THE WEED 
 ALGORITHM 
 
29 
 
 -jui ai • an 
 
 t I -■ 
 
 -•/wnocau V- 
 
 nuitrow to 
 • (un^ - tin. 
 
 UM, • 1JML - IXP« 
 
 VU TYPE » CO»STMT 
 3ET PT» TO 
 COISTA»T TABLE 
 
 VAP TYPE - S, OR S, 
 
 ZQ)I TYPE - S, OB S 
 
 EQUATION 
 CLASSIFICATION 
 
 '-' PVt 
 
 •suiTTof ;i 
 
 CON TYPE * J 
 
 (CEXEHAL) 
 
 DELETE 
 OUOKIHATOP. 
 Of* EXPONENT 
 
 MODTPY E8UATI0H 
 TO HAKE 
 OP - • 
 
30 
 
 :■ mCBS 
 
 LEFT I RI»T 
 DPIMNOE 
 
 crawcm 
 
 SLS2IXP FROM 
 US2LX 4 S1S2KX 
 
 ■P - 1 
 
 Binary Opirotlon 
 
 SL32EXP * 2 
 
 S1S2EXPT * 
 EXPTP * 5 
 CALL II ON LIN 
 
 REPLACE VARIABLE 
 IN TREE BY 
 CONSTANT 
 
 VARIABLE TYPE * L 
 
 S1S2EXP * 
 
 _(J RETURN 
 
 Unary Operation 
 
 3IS2EXP* 1 
 
 PROCESS 
 
 LEPT 
 
 OPERAND 
 
 SLS2EXP ♦ S1S2LX 
 
 THE PROCESS ROUTINE 
 
31 
 
 1 
 
 Y 
 
 r 
 
 ADD COKSTAXTS 
 RESULT TO L OB (L.R) 
 UPDATE CONSTANT TABU 
 DEISTS COHSTAIIT ON 
 P OR (L,Ri RODE 
 
 DETERMINE EXPJ 
 .''BOH LX AND RX 
 
 CALL NONLIN 
 EXPTP * 5 
 
 EVALUATE EXPR 
 UPDATE OONST TABLE 
 
 REPLACE EXPR 
 WITH RESULT 
 EXPTP » OR 1 
 
 REPLACE EXPRESSION 
 WITH CONSTANT '1' 
 EXPTP - 1 
 
 DELETE RIGHT 
 NO IE 
 EXPTP * LX 
 
 EVALUATE EXPR AND 
 REPLACE WITH RESUUT 
 
 EXPTP - OR 1 
 
 CALL NONLIN 
 EXPTT « 5 
 
 PROCESS ROUTINE 
 (BINARY OPERATIONS) 
 
32 
 
 PROCESS ROUTINE 
 (MULT/DIV) 
 
 MULTDIV 
 
 I 
 
 BUBBLE 
 UNABY-'i 
 
 ' 
 
 ' 
 
 
 
 OP = /? ^ 
 
 j£n 
 
 CALL NONLIH 
 
 N^ 
 
 ■^S -EXPR ^V. 
 
 
 ^ ON LEFT? ^S 
 
 
 
 
 
 *I 
 
 
 
 EXPTP - 5 
 
 
 
 
 RETURN 14 
 
33 
 
 :. tast 'O 1 
 
 EVALUATE FUNCTION 
 REPLACE EXPR WITH 
 RESULT. UPDATE 
 CONST. TABLE 
 EXPTP * OH 1 
 
 BUBBLE 
 UNARY- 
 (IF ANY) 
 
 DELETE BOTH 
 UNARY-' s 
 
 COMPLEMENT CONST 
 UPDATE CONST 
 TABLE DELETE 
 UNARY - 
 
 :a^i NONLIN 
 ' - 5 
 
 PROCESS ROUTINE 
 (UNARY OPERATIONS) 
 
AEC-427 
 16/68) 
 -*l M 1201 
 
 U.S. ATOMIC ENERGY COMMISSION 
 
 UNIVERSITY-TYPE CONTRACTOR'S RECOMMENDATION FOR 
 
 DISPOSITION OF SCIENTIFIC AND TECHNICAL DOCUMENT 
 
 I See Instructions on Reverse Side ) 
 
 i C .aPORT NO 
 
 COO-1U69-0181 
 
 TITLE 
 
 WEED 
 
 A WONDERFUL EQUATION ELIMINATION DEVICE 
 
 3 TYPE OF DOCUMENT (Check one) 
 
 Scientific and technical report 
 I I b Conference paper not to be published in a journal 
 
 Title of conference 
 
 Date of conference 
 
 Exact location of conference 
 
 Sponsoring organization 
 
 c. Other (Specify) Th^gJS 
 
 4 RECOMMENDED ANNOUNCEMENT AND DISTRIBUTION (Check one): 
 
 r-1 a AEC's normal announcement and distribution procedures may be followed. 
 
 1] b. Make available only within AEC and to AEC contractors and other U.S. Government agencies and their contractors. 
 I I c. Make no announcement or distrubution. 
 
 5 REASON FOR RECOMMENDED RESTRICTIONS: 
 
 6 SUBMITTED BY NAME AND POSITION (Please print or type) 
 
 C. W. Gear 
 Professor and 
 Principal Investigator 
 
 Organization 
 
 Department of Computer Science 
 University of Illinois 
 ana, Illinois 6l801 
 
 Signature 
 
 u. 
 
 Date June 1971 
 
 FOR AEC USE ONLY 
 
 '""' AEC CONTRACT ADMINISTRATOR'S COMMENTS, IF ANY, ON ABOVE ANNOUNCEMENT AND DISTRIBUTION 
 RECOMMENDATION: 
 
 PATENT CLEARANCE 
 
 II a. AEC patent clearance has been granted by responsible AEC patent group. 
 21 b Report has been sent to responsible AEC patent group for clearance. 
 I I c. Patent clearance not required. 
 
N* N 
 
 ^ V