1959 PROCEEDINGS OF THE WESTERN JOINT COMPUTER CONFERENCE
92
and, if PI = expo,
where
(J
= -x-!(-N_N_~_X_)-!
=
(4)
po« 1.
M(z) =
(J
2N
(5)
Expanding (1-p)k in terms of a power series and retaining only the first term, (1)-(3), respectively, become
(6)
Pl'
2N
= -~
Simplifications can be made in (1)-(3), if systems of
inherently high reliability are considered. That is, if
PI« 1,
~{r~(N)[' ~(~)(~) p~zJ}
r
r=O
(r)z Pi
L (N)
- -
r=N
r=z
r
x
:1:=0
z
Z -
•
x
a
Z
(7)
x
(8)
ACKNOWLEDGMENT
The authors would like to thank the U. S. Department of Defense for permitting the publication of this
paper. Valuable suggestions by C. L. Christiansen,
R. J. Sippel, and P. J. Nelson contributed greatly to
this paper.
A Compiler with an Analog-Oriented Input Language
M. L. STEINt,
J. ROSEt,
INTRODUCTION
ANALOG computation is, for many problems, more
rt. convenient than digital computation but lacks
the precision obtainable from a digital-computer
solution. A compiler has been developed which, for
problems involving differential equations expressible in
the form
i = 1, 2, ... , n
(1)
combines to a considerable extent the desirable attributes of both types of computation. The compiler
achieves this by deducing from a description of an
analog setup diagram the differential equations which
the analog computer solves, and then compiling a program for solving the equations.
Two drawbacks are avoided. The differential equations represented by a diagram are deduced with no
attempt to simulate the analog computer, and a sophisticated integration procedure is used. Therefore, an
accurate and relatively efficient digital-computer program is obtained. Even though the solution is obtained
from the differential equations, the identity of the output of each element on the diagram is not lost, so that
the results may be visualized more easily as the response to the physical system being studied.
The integration procedure used in the final program
IS the GilP version of the fourth-order Runge-Kutta
t University of Minnesota, Minneapolis, Minn. The work of this
author was supported in part by Convair-Astronautics.
t Convair (Astronautics) Div., General Dynamics Corp., San
Diego, Calif.
1 S. Gill, "A process for the step-by-step integration of differential
equations in automatic digital computing machines," Proc. Cambridge
Phil. Soc., vol. 47, pp. 96-108; June 3, 1950.
AND
D. B. PARKERt
method. Since no starting procedure is required, and
because the discontinuities introduced by nonlinear
analog elements cause no difficulty, this method Was
adopted.
The compiler is not the first digital computer program
with an input language related to differential analyzers;
for example, there are the programs DIDAS2 and
DEPI.3 However, the program which this paper describes differs from other similar programs of which the
authors are aware in one or more of the following
respects:
1) The input language is closely related to an extensively used electronic analog computer.
2) The user need not provide his own input and output program. The compiler provides a complete
program ready to run.
3) Since the final program produced is in machine
language, it is efficient in terms of execution time
as compared to an interpretive program.
4) Rather than simulating a differential analyzer, the
compiler deduces from a setup diagram the differential equations represented by the diagram.
In producing a program to solve the differential equations expressed by an analog setup diagram, the compiler uses a technique of increasing popularity.4 This
technique is the use of another processor as an inter2 G. R. Slayton, "DlDAS," presented at the Twelfth Natl. Meeting of the Assoc. for Computing Machinery; June, 1958.
3 F. H. Lesh and F. R. Curl, "DEPl, An Interpretative DigitalComputer Routine Simulating Differential-Analyzer Operations,"
Jet Propulsion Lab., California lnst. Tech., Pasadena, CaliL, Memo.
No. 20-141; March 22, 1957.
4 Communications of the Assoc. for Computing Machinery, vol. 1,
no. 7, p. 5; July, 1958.
From the collection of the Computer History Museum (www.computerhistory.org)
Stein, Rose, and Parker: A Compiler with an Analog-Oriented Input Language
mediate step. In this case the intermediate processor is
Fortran,5 an automatic coding system developed by
IBM which accepts statements closely resembling the
ordinary language of mathematics as input. The output
of the compiler is in the input language of Fortran, and
is translated by Fortran into machine language.
Through the use of Fortran, the task of developing the
compiler was greatly simplified.
The method used to deduce the differential equations
represented by a setup diagram through analysis of its
description is developed in a previous paper by two of
the authors.6 Therefore the method will not be developed here. Instead it will be illustrated by example. A
description of the preparation of problems for the compiler and a description of the compiler will be given.
The application of the compiler will be illustrated with
the solution of a simple problem, and in conclusion, experience in its use will be discussed.
THE ANALOG SETUP DIAGRAM DESCRIPTION
The conversion of an analog setup diagram to a
digital-computer program involves several steps. The
diagram is described. The description is processed by
the computer and a Fortran program is produced. The
program is compiled by Fortran into a machine language program ready to be run. All of these steps except
the first are performed by an IBM 704. This first step,
the description of the diagram, will now be discussed.
A nalog Elements Recognized
In order to analyze the description of an analog setup
diagram, the compiler must be able to recognize the
more commonly used analog elements. Those elements
available on the Electronics Associates PACE electronic analog computer were chosen as representative.
These elements are listed in Table I. The diagram symbols for the elements are those most commonly used fqr
PACE setup diagrams. The mathematical expression
for the function of each element is chosen so that problems prepared for PACE computers can be converted
to digital programs with little or no change in the setup
diagram. For this reason, the scale factors associated
with multipliers and dividers are included, and resolvers
involve angles measured in volts where one volt equals
two degrees.
Norm.ally, scaling requirements for an analog computer are quite restrictive; but since the operations in
t~e digital computer program are performed in floatingpoint form, all numbers, including parameters associated with elements, can vary over a much wider range
in the digital computer. Therefore, diagrams to be
processed by the compiler need not be scaled for an
analog computer.
Ii J. W. Backus, et al., Programmers Reference Manual for the
Fortran Automfltic Coding System for the IBM 704; December, 1957.
6 M. L. Stein and J. Rose, "The Automatic Deduction of Differential Equations from Analog Setup Diagrams," Mathematical PrePrint Series, Pre-Print No. 13, Convair-Astronautics, San Diego,
Calif.
93
In addition to the use of amplifiers as s~mmers and
integrators, special one-amplifier circuits representing
more complicated transfer functions are sometimes used
on electronic analog computers in order to save analog
elements. Such use of amplifiers is not permitted on
diagrams whose description is to be processed by the
compiler. One-amplifier circuits generating special
transfer functions must be replaced with equivalent
circuits using elements in Table I.
Two of the elements, element 13 and element 14,
listed in Table I do not correspond to actual analog elements, but have been included for convenience and for
the compilation of more efficient digital programs. Element 13, the Fortran statement, is included to allow
the replacement, if desired, of feedback loops generating
functions such as X 2 / 3 , eX, etc., by a Fortran statement
utilizing a library subroutine in order to obtain a more
efficient digital program. Element 14, the external input,
is included to allow the combination of compiler-generated Fortran programs with other Fortran programs.
The Preparation of a Diagram Description
The compiler converts an analog-comp'uter problem
to a program by processing information supplied in a
description of the analog setup diagram. Therefore, the
preparation of an accurate diagram description by the
user of the compiler is an essential step in the process of
obtaining a correct digital program.
Before beginning the description of a diagram, however, it should be determined that the problem is of a
type suitable for conversion. While the analog computer
is capable of solving several types of problems, the compiler is restricted to problems involving differential
equations expressible in the form (1). That is, no implicit relationships are allowed among derivatives or
among other variables. The compiler detects implicit
relationships by discovering the presence on the diagram
of feedback loops without integrators, a procedure
whose suitability for detecting implicitness is demonstrated in a previous paper.6 Therefore, the diagram
should be examined for such loops before preparing the
description.
Having determined that the problem is of a suitable
type, the diagram must be examined for elements other
than those listed in Table I. Circuits involving other
elements must be replaced by equivalent circuits using
acceptable elements. Circuits for obtaining powers,
roots, arctangents, exponentials, and natural logarithms
may be replaced, if desired, by Fortran statement elements.
After it has been determined that the problem is of a
suitable type and that all circuits are acceptable, the
actual process of describing the diagram is clerical in
nature. Consequently, the description may be done by
an engineering aide, freeing the engineer who originated
the problem for tasks making better use of his skills.
The first step in preparing a diagram description is to
assign to each element on the diagram an arbitrary
From the collection of the Computer History Museum (www.computerhistory.org)
1959 PROCEEDINGS OF THE WESTERN JOINT COMPUTER CONFERENCE
94
TABLE I
ELEMENTS RECOGNIZED BY THE COMPILER
DIAGRAM
SYMBOL
NAME
COMPILER
SYMBOL
FUNCTION
= constant
Reference
RF
P=R
2
PotentIOmeter
PT
P
3
Summer
SU
P = -(alII + a 1 + . . . +a7 17 )
2 2
~ = 1, 5, or 10
Integrator
IN
R
= KI
K
= constant
t
P + C -
J
to
(a 1 I
1
+a
2
a k = 1, 5, or 10
5
PI
Servo
MultiplIer
MS
==
Electronic
MultIplier
C = constant
11 x 1/ 100
P 2 = 11 x 1/100
P3
6
12 + . . +a7 17) dt
= 11 x
I i 100
PI = - 11 x 1/100
ME
P 2 = - 11 x 1/100
7
8
DIvider
LImiter
DI
I
--I
u
Limiter
~P
P = U, lor L
LM
as I ~ U,
L
9
10
11
Rectangular
to Polar
Resolver
Polar to
Rectangular
Resolver
Switch
Function
12
Statement
External
Input
+
I 2
2
pool sin (I )
3
3
1
PI = 12 sin (11)
P 2 = 12 cos (\)
11~
~
1-1 Function
r
SW
~
11"1 - " Fortran r- P
2
Statement
:
I
External
~
If I <o,® and
1
If Ilo,@ and
P
FG
=F
®
®
and
®
are connected.
@
®
and
(i)
are connected.
(1) au determined by linear
interpolation in a table.
FS
a Fortran "arithmetic formula"
17- - ' -_ _-'
14
V
pool 2
1
1
PR
Generator
Fortran
13
RP
U> 1 >L, or I ~ L respectively
P must be defined by another
p
EI
Fortran program.
From the collection of the Computer History Museum (www.computerhistory.org)
Stein, Rose, and Parker: A Compiler with an Analog-Oriented Input Language
number between 1 and 999. Using a suitable input form
of the type shown in Fig. 1, the elements are described
one at a time in any convenient order. An element's
number is entered on the form. Then its type is designated as given in Table I-for example,
for a summer. If the element has parameters associated with it,
the values of the parameters are entered on the form.
If the output of the element is to be printed, an N for
normal output or a C for checkout output is written on
the form. The inputs to the element are then listed by
entering the numbers of the elements from which the
inputs come. If the element is an integrator or a summer, the scale factors associated with the inputs are
listed. As an example, Fig. 2 shows the complete entry
for element 2, an integrator whose single input is equal
to five times the first output of element 6, an electronic
multiplier, and whose initial output is -45.
Each element is described in a fashion similar to that
above on one line of the input form. When all elements
have been described and the descriptions checked, the
form is given to a key-punch operator, who punches
each line on a card. These cards become the input to the
compiler.
/~,
+~
R. K.
c.
U
L
;p-" "'....
~~
.. ,,'"
~ '"
,s:"
~
95
,,"
~~'"
..'",,"
~
. '",,"
~
,,~
~~"
sa
Fig. 1-Input form for the compiler.
Fig. 2-Input form entry for one element.
PI
P2
1
3
THE TRANSFORMATION PROCESS
In order to transform a description of an analog setup
diagram into a digital-computer program, the compiler,
using a procedure developed in a previous paper,6 must
deduce the differential equations which the diagram
represents. Having deduced the equations, the compiler
must then produce a Fortran program suitable for
solving the equations. These two major phases of the
transformation process will now be described and will
be related to the complete compiler program.
First, the differential equation of a simple diagram
will be deduced. In Fig. 3 we see the diagram for the
equation
y = R - Ky.
(2)
Pi represents the output of element 1, P2 the output of
element 2, etc., and D2 represents the 'total input to
element 2, an integrator. Examination of the types of
elements 1 and 3 (see Table I) permits the equations
Pi ! R
(3)
P3 = KP2
(4)
to be written. Examination of element 2 discloses that
it is an integrator. The equation for its input can be
written as
D2 =
+ Pi + P3
(5)
If (3) and (4) are substituted into (5), the equation
D2 = R
+ KP2
(6)
is obtained. Recalling that
P2
=
C -
f
t D2dt ,
to
'
Fig. 3-Diagram for y=R-ky.
as shown in Table I, (6) is seen to be equivalent to (2).
Therefore, given values for C (the initial value of P2),
R, and K, a solution for (2) can be obtained through use
of a suitable numerical integration procedure.
Actually, (3)-(5) need not be combined if they are
evaluated in the proper sequence, since all that is required to carry out the numerical integration is that
it be possible to obtain a value for D2, given a value of
R, K, and P2. If equations are not to be combined, deducing the differential equations from a diagram description consists of determining the proper sequence
for evaluating each element and then producing equations for evaluating the output of each element with the
exception of integrators, whose input must be evaluated
as seen above. Leaving equations uncombined leads to a
somewhat less efficient computer program. However, it
has the advantage of preserving the identity of the output of every element, a useful property when programs
are debugged, and also aids in visualizing the results as
the response of the physical system being studied. Since
a procedure for deducing differential equations is easier
to implement, too, if equations are left uncombined,
this method was ch<fsen for the compiler.
If equations are not to be combined, the process of
converting a description to Fortran input language can
be divided into two distinct phases: 1) the determination of the proper sequence for evaluating integrator
inputs and non integrator element outputs, and 2) the
generation of suitable Fortran statements for obtaining
From the collection of the Computer History Museum (www.computerhistory.org)
96
1959 PROCEEDINGS OF THE WESTERN JOINT COMPUTER CONFERENCE
the value of these inputs or outputs as a function of the
outputs of other elements. The former phase, sequencing, will now be considered.
Sequencing
In order to give a pictorial presentation of the sequencing process, a table giving the proper sequence
for the evaluation of the elements of an abstract analog
diagram will be constructed in a fashion similar to that
which the compiler would employ.
An analog setup diagram is given in Fig. 4 for a firstorder differential equation; that is, only one integrator
appears. Since the sequencing process need distinguish
only between elements which are integrators and those
which are not, types of elements other t~an that of element 7, an integrator, are not specified. Given a description of the diagram, the first step in constructing
a sequence table is to locate an integrator, in this case
element 7, and enter its number in a sequence table.
Examining the description of element 7, one of its inputs, element 3, is selected for consideration, the number
of 3 is entered in the sequence table and its description is
located. Proceeding to 3's input 5 and entering 5 in the
table, the description of the portion of the diagram indicated by the heavy line in Fig. 5 has been examined,
and the entries in the sequence table shown in Fig. 5
have been made. Since 5 has no inputs, element 3 must
be reselected and its description examined for additional
inputs which have not yet been selected. Element 3
has a second input, 1, which has not yet been examined.
Proceeding in the manner similar to that above, 1, 6,
and 4 are entered in the table as shown in Fig. 6. After
4 has been entered in the table, since 4 has no inputs, 1
is reselected, but both of its inputs have been examined.
Therefore 3 is reselected, but both of its inputs have
been examined also. This leads to the reselection of 7
and the examination of its second input, 8.
The tracing of the inputs to 8 will disclose an interesting feature of the sequencing process. This feature is
that elements with split outputs such as element 1 cause
duplication of entries in the sequence table. Examination of the description of 8 reintroduces 1 for selection.
Examination of 1 rein trod uces 6 and 4 as shown in Fig.
7. Since 4 has no input, and both inputs of 1 have been
examined, 8 is reselected. Element 8's second input is
2, and 2's input is 9. Therefore, 2 and 9 are entered in the
table. The reselection of 2 and the examination of its
second input discloses that its second input is element
7, an integrator.
Inputs to elements which are the outputs of integrators are treated as a special case. The element number
of an integrator is never entered in a sequence table
except as an initial entry. The reason: no expression for
evaluating the output of an integrator need be written.
The value of the output of the integrator is supplied
by the numerical integration. Since 2's second input is
7, an integrator, no table entry is made.
Fig. 4-An abstract analog setup diagram.
Sequence Table
Fig. 5-Partially examined diagram description.
Sequence Table
Fig. 6-Partially examined diagram description.
Sequence Table
4
4
Fig. 7-Partially examined diagram description
with reintroduction of 1, 6, 4.
Sequence Table
~
I
I
I'"- _ _ _ _ _ _ _ _ _ _ _ _
JI
4
1
6
Fig. 8-The completed examination of the diagram description.
At this point, all inputs to every element of the diagram have been examined and the sequence table is
complete. The compiler discovers that the examination
of the diagram description is completed in the following
fashion. Since both inputs to 2 have been examined, 8 is
reselected for examination. Both inputs to 8 have also
been examined. Consequently 7 is reselected, but both
inputs to 7 have been examined and 7 is the initial entry
in the sequence table. Thus, examination of the diagram
description is completed as shown in Fig. 8.
From the collection of the Computer History Museum (www.computerhistory.org)
Stein, Rose, and Parker: A Compiler with an Analog-Oriented Input Language
While the examination of the diagram description is
complete, the sequence table is not yet finished. Redundant element numbers must be eliminated with the
lowest occurrence of a number retained as shown in
Table II, and the table must be inverted and compressed
as shown in Table III in order to obtain a proper sequence for evaluating the elements.
TABLE
II
TABLE III
SEQUENCE TABLE WITH
REDUNDANCIES ELIMINATED
FINAL SEQUENCE TABLE
(TABLE II INVERTED)
7
3
5
8
1
9
2
4
6
1
8
5
3
6
4
2
9
7
97
Fortran statements for evaluating elements, will now
be considered.
In contrast to the sequencing phase, the generation
of Fortran statements is lengthy but logically simple.
The compiler begins with the first entry in the sequence
table, and an element number is obtained. The descriptior~ of the element is located, and its type is examined.
On the basis of its type, a set of skeleton Fortran statements is selected, a set being provided for each type of
ele~ent. The inputs to the element are obtained from
its description and are inserted in the proper places in
the skeleton statements. The statements are written on
magnetic tape. Then the next entry in the sequence
table is obtained and the process repeated. In Table IV
we see examples of Fortran statements generated for
each type of element.
In addition to generating statements for each element
as described above, the compiler generates such other
Fortran statements as are required to obtain a complete
program.
The Complete Compiler Program
The final sequence table, Table III, has been obtained. Comparison of Table III with the diagram of
Fig. 8 shows that if the elements are evaluated in the
order given by Table III, the output of each element 9
through 3 can be calculated and the input to element
7 obtained. Using a suitable numerical integration procedure, the output of 7 can be obtained. Hence, a proper
sequence for solving the differential equation represented by the diagram has been determined.
The illustration above is for a single differential equation. If the diagram involves several differential equations, that is, several integrators, a slight elaboration of
the procedure used above is required. An integrator is
found and a sequence table is constructed as shown
above. All elements in the final sequence table are defined as being complete. Another integratior is found, and
the procedure above is repeated with the additional provisions that those inputs which come from complete elements give rise to n,o table entries, and that complete
elements are not selected for examination of their inputs.
The final sequence table obtained for the second integrator is added to the sequence ~able for the first. The
process is continued until all integrators have been
found and a sequence table has been obtained for the
entire diagram.
A previous paper6 proves that the procedure demonstrated above does obtain in all cases the proper sequence for diagrams involving equations of form (1) and
develops a method for, detecting equations not of form
(1). This method was not demonstrated above, but is
included in the compiler.
Generation of Fortran Statements
The second phase of converting <l: setup diagram to
Fortran input language, the generation of suitable
The complete compiler program including the sequencing and statement generation portions will now
be described in terms of the functions which the program performs. These are as follows:
1) It tabulates the data supplied in the description of
the analog setup diagram.
2) The differential equations represented by the diagram are deduced through determination of the
proper sequence for evaluating el,ements.
3) Fortran statements providing a complete program
are generated.
4) As the data of the diagram description is processed,
it examines the data for errors.
These functions divide the compiler into four major
segments-the input routine, the sequencer routine, the
Fortran statement generator, and the error diagnostic
routine.
The Input Routine: The input routine reads the description of the elements into the computer memory and
forms various tables. These are a table of elements
which have associated parameters, a table of the values
assigned to these parameters, a table of elements which
are integrators, and a table of those elements whose
output is desired for printing.
The Sequencer Routine: The sequencer routine forms
a table showing the order in which integrator inputs and
nonintegrator element outputs must be evaluated.
The Fortran Statement Generator: The Fortran statement generator produces a Fortran program the parts
of which are concerned with the following operations:
1) Assignment of memory locations for data;
2) Assignment of values to all parameters associated
with elements including the initial values of integrator outputs;
From the collection of the Computer History Museum (www.computerhistory.org)
98
1959 PROCEEDINGS OF THE WESTERN JOINT COMPUTER CONFERENCE
TABLE IV
AN EXAMPLE OF FORTRAN STATEMENTS FOR EACH TYPE OF ELEMENT
Element
Statement Number
Statement
reference
00101
Pl0l =XR10l
poten tiometer
00002
P002 = XK002 * POOl
summer
00016
P016= -P001-P002-5. * P0051-10. * P006
integrator
00004
P004= +P003+10. * PO 11 +5. * POO71
servo multiplier
00005
P0051 = PO 11 * P0071/100.
P0052 = POll * P001/l00.
P0053=P011 * P003/100.
electronic multiplier
00007
P0071 = -P003 * P0051/100.
P0072 = -P003 * P002/100.
divider
00008
P008 = -100. * (P0071/P019)
00095
01095
04095
05095
IF (P094 -XU095) 02095, 01095, 01095
P095=XU095
GO TO 05095
IF (P094-XL095) 04095,04095,03095
P095=P094
GO TO 05095
P095=XL095
CONTINUE
00015
POlS = P009 * * 1. 5 +EXPF (P012 -17 .6)
limiter
02095
03095
Fortran statement
external input
rectangular
to polar resolver
no statement required
00034
P0341 = SQRTF (P029 * *2 +P028 * *2)
IF DIVIDE CHECK 01034,01034
01034
02034
IF QUOTIENT OVERFLOW 02034, 02034
TANP2 = P028/P029
IF DIVIDE CHECK 04034,03034
IF QUOTIENT OVERFLOW 04034, 07034
IF (P028) 05034, 20000, 06034
PN2= -45.
GO TO 08034
PN2=+45.
GO TO 08034
PN2=ATANF (TANP2) * 28.6478897
IF (P029) 09034, 11034, 11034
P0342 = PN2 +90.
GO TO 12034
P0342=PN2
CONTINUE
03034
04034
05034
06034
07034
08034
09034
11034
12034
polar to
rectangular resolver
00022
P0221 =P023
P0222 = P023
P0223 = P025
P0224 = P025
00100
01100
IF (P011) 01100, 02100, 02100
Pl003=P098
Pl006=0.
GO TO 03100
Pl003=P099
Pl006=0.
CONTINUE
switch
02100
03100
00012
01012
function
02012
generator
03012
* SINF (.03490658 * P008)
* COSF (.03490658 * P008)
* SINF ( .03490658 * P008)
* COSF ( .03490658 * P008)
IF (P003 - V012( 1) 30000, 01012, 01012
DO 02012 K= 1, M012
IF (P003 - V012 (K))03012, 02012, 02012
CONTINUE
GO TO 30000
P012=W012 (K)-(W012(K)-W012 (K-1))*
(V012(K) -P003)/(V012(K) - V012(K-l))
From the collection of the Computer History Museum (www.computerhistory.org)
Stein, Rose, and Parker: A Compiler with an Analog-Oriented Input Language
3) Read-in of tables for function generators, of parameter changes, and of various constants associated with a particular run-the integration interval, the printout interval, the type of output, the
cutoff time, and the number of parameter changes;
4) Numerical integration;
5) Evaluation of derivatives, that is, the computation
of the outputs of all elements which are not integrators and computation of the inputs of integrators;
6) Finally, provision for printing output and testing
for cutoff time.
The Error Diagnostic Routine: The detection of errors
occurs in either the input routine or the sequencer. The
function of the error diagnostic routine is to print a complete explanation of the type of error detected, the
numbers of the elements involved, and other pertinent
information to enable the user to locate and correct
errors in the diagram or in its description. The error
diagnostic routine must also make such changes in the
diagram description as are required in order to allow the
compiler to continue to the end of sequencing so that
several errors may be detected in one compilation
attempt.
AN EXAMPLE OF THE USE OF THE COMPILER
The solution of a simple problem will now be presented as an illustration of the use of the compiler. The
authors are indebted to Robert Ferner of ConvairAstronautics for the preparation of the problem given
below.
The problem to be solved involves the testing of a
possible transfer function for translating an error in
velocity normal to a reference trajectory of a missile
into a turning rate to the missile's autopilot. The autopilot is approximated by the transfer function,
10
G=----S2
4S
10
+
+
(7)
The acceleration of the missile is given by
100,000·32.2
Tg
A=-----
W- 1,'Wdt
50,000 - 1, '500dt
The form of the transfer function to be tested is
W
KI
Ve
S
+
K 2S
+ Ka
(8)
with K 1 , K 2 , and Ka to be determined for stability and
ability to correct V e , the error in velocity. The rate input
. to the autopilot is limited in magnitude to 0.02.
A setup diagram fdr this problem is shown in Fig. 9.
The elements on the diagram have been numbered arbitrarily in preparation for a description of the diagram.
99
Fig. 9-Setup diagram for transfer function problem.
The description of the diagram is given in Fig. 10.
A list of cards keypunched from the description is
shown in Fig. 11, and a list of the Fortran program
generated by the compiler is given in Fig. 12. This program was processed by Fortran, and the resulting machine program was run. The results of a run with
K 1 =0.003, K 2 =0.0035, and Ka=0.5 are shown in Fig.
13. Finally, a graph of the results as plotted by a card
plotter is given in Fig. 14.
EXPERIENCE WITH THE COMPILER
To date, a "breadboard" version of the compiler has
been in use. It differs from the final version in that the
error diagnostic routine is not completed. The detection
of an error in the diagram description ends the compilation attempt by giving a memory dump. Consequently,
the "breadboard" compiler is not as convenient to use,
inasmuch as several passes on the computer may be
required if several errors are committed in describing
the diagram. In spite of this shortcoming, the "breadboard" compiler has proven to be quite useful.
Nine problems have been done with the compiler to
date; consequently, accurate statistics on its use are not
available. However, orders of magnitude can be given.
The analog diagrams for the problems ranged in size
from approximately 20 elements to over 300 elements.
The time required to prepare and check the diagram
descriptions varied from one hour to about six hours
for the largest problem. The computer time required to
compile the program (including Fortran compilation)
was from one-tenth of an hour to approximately one
hour. The programs for problems which had also been
run on the analog computer used approximately four
times the amount of computer time required for an
equivalent but less accurate analog run. These were
small problems, however. Larger problems would give
a much more unfavorable ratio.
As would be expected, the users of the compiler have
been far more familiar with analog than digital computation. Nevertheless, it has been possible for them to
originate problems for the digital computer and obtain
solutions as accurate as those provided by hand-tailored
programs. In general, this lack of familiarity with digital
techniques has caused little difficulty since the compiler
causes the digital computer to have many of the proper-
From the collection of the Computer History Museum (www.computerhistory.org)
. 1959 PROCEEDINGS OF tHE WESTERN JOINT-COMPUTER CONFERENCE
100
A
~43' . .~'v
,~{ . (
R,
'"
1
T
. 0
2
T
1 0
3
~
~o/.
K, C, U
o0
L
,I.
~
1
S
4. S U
..
- f-f--
C
1 5
C
9
lJ
2 3
;;
1 b
C
2 0
1 3
0
N
3 . 2 2 E 6
C
7
8
~
F
M
...
9 I N
0
1 0 IN
0
o2
-
o
~'"
.:$'~
8.~
~
~
"
C
6 IN
~"J
~'"
.:$'~
N
.
;;
.:$'~
~
T
;;
~'
~'"
-s'"
~<;,
~
--<
0
-s~~'"
8.~
'\,~
'"
'"
'"
.:s~'"
v
IN
2
C
8
IL
1 4
1 1
1 8
:
1 1 IPT
4
1 2 ~F
5
1 3 IN
0
1 4 kF
;; 0 0
9
E 4
C
l~
2
C
1
1 5 IN
0
C
4
1 6 IN
1 0 0
N
3 1
1 7 SU
N
1 9
1 8 SU
C
1 3
1 9
P1'
o
1.11
1
C
2 1
2 0 SU
C
1 5
au
C
4
2 2 SU
C
1 2
1 0
I
N
7
2 2
2 1
2 3
0 2 0
L.--'-
L-L--L.-----=
-
.,._1.-1.........
.... """
....-
-- _
..............
/-
Fig. 10-Description of diagram for transfer function problem.
AUTOPILOT TRANSFER FUNCTION
16IN 100.
N
31
17SU
19
N
8LM +.02
-.02
N
17
13IN O.
2
N
6IN O.
N
13
23DI
N
7
3MS
N
6
lPT .0001
15
C
2PT 10.
C
9
4SU
C
5
5PT .5
20
C
7RF 3.22E6
C
9IN O.
8
C
lOIN O.
14
C
llPT 4.
C
9
12RF 5.E4
C
14RF 500.
C
15IN O.
4
C
18SU
13
C
19PT .0020
21
C
20SU
C
15
21SU
4
C
22SU
12
C
1
22
23
16
18
11
10
Fig. 11-List of cards punched from description. (The sequence
has been altered to order problem output.)
From the collection of the Computer History Museum (www.computerhistory.org)
-
'\
1
2
3
1
2
20000
20001
20002
1
20003
20004
20005
20006
20007
20008
20009
20010
20011
20012
20013
20014
20015
AUTOPILOT TRANSFER FUNCTION
DIMENSION A(12), X(017), Y(007), Q(007)
EQUIVALENCE (X(OOl), T), (X(002), P016), (Y(002) , D016),
(X(003) , P013), (Y(003), D013), (X(004), P006), (Y(004), D006),
(X(005), P009), (Y(005) , D009), (X(006), POlO), (Y(006) , DOlO),
(X(007), POlS), (Y(007), D015)
EQUIVALENCE (X(008), XU008), (X(009), XL008),
(X(010), XK001), (X(Ol1), XK002), (X(012), XK005), (X(013), XR007),
(X(014), XKOll), (X(015), XR012), (X(016), XR014), (X(017), XK019)
A(1) = .5
A(2) = .29289322
A(3) = 1.7071068
A(4) = .16666667
A(5) = 1.
A(6) = .29289322
A(7) = 1.7071068
A(8) = .33333333
A(9) =.5
A(lO) = .29289322
A(l1) = 1.7071068
A(12) = .5
X(OOl) =0.
X(002) = 100.
X(003) =0.
X(004) =0.
X(005) =0.
X(006) =0.
X(007) =0.
X(008) = + .02
X(009) = - .02
X(010) = .0001
X(Oll) = 10.
X(012) = .5
X(013) =3 .22E6
X(014) =4.
X(015) = 5. E4
X(016) =500.
X(017) = .0020
READ 20001, NTO, MP, DT, CT. ~C
FORMAT (11, 18, F16.8, F15.8, 19)
PRINT 20002
FORMAT (49H1AUTOPILOT TRANSFER FUNCTION
55HO
TYPE OUTPUT
OUTPUT INTERVAL
TIME INTERVAL)
IF (NTO)20003, 20005, 20003
PRINT 20004, MP, DT
FORMAT (14H
CHECKOUT, 115, F23.6)
GO TO 20007
PRINT 20006, MP, DT
FORMAT (13H
NORMAL, 116, F23.6)
PRINT 20008, CT, NC
FORMAT (33HO
CUTOFF TIME
NO. CHANGES/1H, F19.6, 110)
IF(NC)20015, 20015, 20009
PRINT 200010
FORMAT (31HO
XCI))
DO 20013 J = 1, NC
READ 20012, I, (X(I))
FORMAT (13, F14.8)
PRINT 20014, I, (X(I))
FORMAT (1H, 111, F23.8)
ASSIGN 20022 TO JUMPl
ASSIGN 20026 TO JUMP2
ASSIGN 20016 TO JUMP3
GO TO 20017
20016 ASSIGN 20018 TO JUMPl
ASSIGN 20023 TO JUMP2
ASSIGN 20031 TO JUMP3
N=MP
20017 DO 20023 J = 1, 4
GO TO JUMP1, (20022, 20018)
20018 DO 20021 1=1,007
IF (Y(I)) 20020, 20019, 20020
20019 R=O.
GO TO 20021
20020 S= -DT * Y(I)
R=A(J) * S-A(J +4) * Q(I)
XCI) =X(I)+R
Q(I) =Q(I)+3. * R-A(J +8) * S
20021 CONTINUE
20022 Y(l)=-1.
00001 POOl = XKOOl * POlS
00002 P002 = XK002 * P009
00012 P012=XR012
00022 P022 = -P012-P010
00007 P007=XR007
00023 P023 = -100. * P007/P022
00003 P0031 =P023 * P006/100.
00020 P020= -POlS
00005 P005 = XK005 * P020
00004 P004 = - P005 - P016
00006 D006= +P013
00021 P021 = -P004
00019 P019=XK019 * P021
00017 P017 = -P019-POOl
00008 IF(P017 -XU008)02008, 01008, 01008
01008 P008=XU008
GO TO 05008
02008 IF(P017 -XL008)04008, 04008, 03008
03008 P008=P017
GO TO 05008
04008 P008=XL008
05008 CONTINUE
00011 POll =XKOll * P009
00018 P018= -P013
00009 D009 = +P008+P018+P011
00014 P014=XR014
00010 D010=+P014
00013 D013= +P002
00015 D015=+P004
00016 D016 = + P0031
GO TO JUMP2, (20026, 20023)
20023 CONTINUE
20024 N=N-l
IF (N) 20025, 20025, 20031
20025 N=MP
20026 IF (NTO) 20027, 20029, 20027
20027 PRINT 20028, T, P016, P017, P008, P013, P006, P023,
1 P0031, POOl, P002, P004, P005, P007, P009, POlO, POll,
2 P012, P014, POlS, P018, P019, P020, P021, P022
20028 FORMAT (1HO, F14.6/(lH, 4F14.6))
GO TO 20030
20029 PRINT 20028, T, P016, P017, P008, P013, P006,
1 P023, P0031
20030 GO TO JUMP3, (20016, 20031)
20031 IF (X(l) -CT) 20017, 20000, 20000
~
~
.....
~
~
~
~
-~
~
~
~
~
~
~
<I:t'
~
~
'.
~
~
~
'\:)-
.....
"-
~
~
~
.....
~
~
~
~
~
~
~
O'q
6
.....
~
~
~
~
~
~
~
~
~
~
~
~
:::
~
~
~
J--Io
o
J--Io
Fig. 12-List of Fortran program generated by compiler.
From the collection of the Computer History Museum (www.computerhistory.org)
1959 PROCEEDINGS OF THE WESTERN JOINT COMPUTER CONFERENCE
102
100
r-r.:----,..-----r-----,----,----.,
AUTOPILOT TRANSFER FUNCTION
TYPE
OUTPUT
NORMAL
CUTOFF
TIME
80.000000
I
10
17
O.TIME
100 .000000 Ve
0.-8
OUTPUT INTERVAL
40
TIME
INTERVAL
0.025000
75~---+_-----~---~---_+---_i
NO. CHANGES
2
X(I)
0.00030000
0.00350000
Ve
0.0
-0.350000w
6439.999878A
-0.020000w
1.000000
99.771433
0.011025
-0.235164
6505.050415
-0.020000
0.717208
-0.020674
1.999999
98.355980
0.032057
-0.161977
6571.428467
-0.020000
2.106574
-0.020226
O.-v
50~~~-+_----+_----~-----_+----~
25~-~--+_-----+_------~------_r----_,
.....
.....
............................
20
2.999998
95.577519
0.052006
-0.113329
6639.174988
-0.020000
3.452772
-0.019941
3.999997
91.439002
0.071998
-0.079243
6708.333008
-0.020000
4.829841
-0.020008
4.999996
85.908216
0.092000
-0.053577
6778.946838
-0.020000
6.236650
-0.019999
5.999995
78.955898
0.112000
-0.032604
6851.063110
-0.020000
7.673180
-0.020000
6.999994
70.551993
0.131932
-0.014055
6924.730286
-0.014055
9.135929
-0.019236
7.999993
60.833487
0.144597
0.002923
6999.998901
0.002923
-0.004096
10 .121800
60
40
80
100
TIME
Fig. 13-A sample of output from the program.
ties of the analog computer as far as the user is concerned. However, the nonlinear elements, the switch
and the limiter, have caused difficulties for the user in
some cases. Either of these elements can introduce discontinuities in the functions being integrated. The response of an analog integrator to a discontinuity is
nearly instantaneous; the response of the digital program is not. The numerical integration tends to smooth
discontinuities, the amount of smoothing depending
upon the integration interval. Then, too, in contrast to
the analog computer, switching or the start of limiting
can only occur at the beginning of or midway in an
integration interval. Because of these effects, a certain
amount of experimenting was sometimes necessary in
choosing an integration interval.
When the compiler was undertaken, it was antici-
Fig. 14-A plot of the velocity error against time.
pated that it would have three uses-checking analog
runs, obtaining greater accuracy for selected analog
runs, or originating problems with no intention of
making any actual analog runs. With the first two uses
in mind, the elements which the compiler recognizes
were made as similar to actual analog elements as possible so that existing analog diagrams could be converted
with little or no change. In practice, the compiler has
been used principally as a convenient way of originating
problems for the digital computer. For these problems,
the c10se duplication of analog idiosyncrasies has proven
to be an inconvenience rather than an aid. Therefore,
consideration is being given to producing another version of the compiler that recognizes elements more convenient for originating digital computer programs.
Experience has indicated that many problems are
solved on an analog computer which cannot be trans'formed into programs by the compiler because of implicit relationships between derivatives or between the
variables. S~me of these problems contain implicit relationships involving nonlinear functions. However, this
type of problem does not occur frequently enough to
justify the effort required to develop a new compiler.
Most of these problems, however, involve implicit relationships which can be eliminated by solving a system
of simultaneous, linear, algebraic equations. Consideration is being given to the extension of the compiler to
inc1ude this type of problem.
In conc1usion, the authors feel that the compiler will
be an extensively used program at Convair-Astronautics
and will fully justify the modest expenditure of effort
involved in its development.
From the collection of the Computer History Museum (www.computerhistory.org)
1959 PROCEEDINGS OF THE WESTERN JOINT COMPUTER CONFERENCE
103
Automatic Design of Logical Networks*
T. C.BARTEEt
HE frequent use of transcendental functions in
digital computer programs has presented a basic
problem in the design of real-time control systems.
Since there are usually no single instructions to perform
such functions as sine x, arc sine x, etc., two other techniques have been used.
The first technique involves storing a table of values
for the function in rapid access memory. The advantage
of this technique lies in the speed obtainable; however,
in order to provide reasonable accuracy, the table must
be of considerable length. Computations which involve
physical measurements such as those made by one of
the newer radars would require a table which would occupy a 'significant portion of most storage devices. An
alternate technique involves storing a smaller table,
and then interpolating between the values stored in this
table. The principal advantage of table ~torage is then
lessened, for the interpolation routine requires time and
the function can no longer be generated as quickly.
The second technique involves the use of a programmed approximation routine. Most of the routines
used are based on polynomial approximations which require several multiplications, and as a consequence, are
time-consuming.
The utilization of digital computers in real-time control systems which must process large amounts of data
at high speeds has made the problem more acute. Most
programs for such systems require values for sines,
cosines, etc., quite often, and the necessary computations must be made quickly and with considerable accuracy. The need therefore exists for a very fast and accurate method of generating trigonometric functions.
Lincoln Laboratory has recently prepared a set of
flexible computer programs which automatically perform the design of logical networks which will perform
such functions in a single step. These networks may
then be connected into the arithmetic element of an internal-binary-operation digital computer, providing the
machine with instructions which will yield the sine, arc
sine, etc., of an angle stored in one of the registers of the
arithmetic element. The design technique yields a logical network with a number of input and output lines,
the input lines representing the independent variable
and the output lines the dependent variable. The networks are completely digital in operation, utilizing highspeed transistor and diode logical circuitry.
Because of the magnitude of the design problem for
large logical networks, conventional manual design tech-
T
* The work reported here was performed at Lincoln Lab., Mass.
Inst. Tech., Lexington, Mass., with the joint support of the Army,
Navy, and Air Force.
t Lincoln Lab., M.LT., Lexington, Mass.
niques could not be used. For instance, the complete set
of expressions needed to describe a 12-input bit and 14output bit sine network in developed normal form contains approximately 90,000 symbols. Normal design
techniques involving manual calculations would prohibit either the generation or simplification of a set of expressions of this complexity. It was necessary, therefore,
to design and prepare a set of digital computer programs
which would automatically generate the desired set of
expressions, simplify them, and then check the simplified equations. The series of programs written are general purpose in design and may be used to generate and
simplify the logical equations describing any function
with a unique value of the dependent variable for each
value of the independent variable.
Only three basic logical relationships or operators are
used in the equations. These are defined as logical addition, logical multiplication, and complementation. Fig.
1 illustrates a standard diode circuit for the logical addition relationship. The inputs to this diode "or" circuit
consist of dc levels of - 5 and 5 volts corresponding to
the logical symbols 0 and 1, respectively. To the left of
the figure is the block diagram symbol for the "or" circui t. The plus sign in the block is also used to indicate
logical addition in the written expressions. This is, of
course, the "inclusive or" function, sometimes referred
to as "logical disjunction."
Fig. 2 illustrates a diode "and" circuit which performs
the logical multiplication function, sometimes referred
to as "logical conjunction." The block diagram symbol
for the "and" operation is to the left of this figure.
Fig. 3 illustrates a two-level diode "and-to-or" circuit.
There are six inputs to this circuit, each consisting of dc
levels. The expression describing this circuit in Boolean
algebra notation is written at the far right of the figure.
This expression may be read a and band c, or d and e
and f or the product of a, band c, plus the product of
d, e and f. According to the notation used, the output
will be equal to 1 only when a and band c or d and e and
fare equal to 1.
The third logical operation used is the complement
function, sometimes referred to as inversion or negation.
A transistor inverter designed for the Lincoln TX-2
computer is illustrated in Fig. 4. A prime sign (') is used
to indicate the" complement" or "not" function in the
expressions. When flip-flops are used to provide the inputs to the networks, complemented as well as the uncomplemented values of the input variables are available.
At a given time each input line to a logical network
will contain a signal representative of either a binary 0
or 1. The fundamental characteristic of the logical net-
+
From the collection of the Computer History Museum (www.computerhistory.org)