There are four classes of constants: Integer, floating point, alphabetic, and Boolean.

The name of a variable consists of one to six letters or digits, the first of which must be a letter. If the variable is defined as an n-dimensional array variable (see Section 3.3, “Dimension Declaration”) then the name of an element of the array consists of the variable name, (i.e one to six letters or digits, starting with a letter), followed by the appropriate subscripts separated by commas and enclosed in parentheses. Thus the following are "single variables:": X51, ALPHA6, LAMBDA, GROSS, while the following are elements of arrays: BETA(C1, C2, 6), X15(Y, Z1), J(6), J(Z1 + 5 *Z2, 5). (See Section 1.11, “Subscript Expressions” for the description of subscripts.) Parentheses enclosing subscripts may not be omitted.

A statement may be labelled or unlabelled. Labels are used to refer to a statement in other statements. A statement label consists of from one to six letters or digits, the first of which must be a letter, e.g. IN or BACK. A statement label may be an element of a statement label vector, in which case the vector name is followed by a constant integer subscript enclosed in parentheses, e.g. S(2) or LBL(3). A statement label appears in the label field (i.e. columns 1-10) of the statement it identifies. When a statement extends to additional cards (i.e. cards identified by a digit punched in col. 11) the statement label need not be punched on the additional cards.

The name of a function consists of one to six letters or digits followed by a period "." which must be written. The first character of a function name must be a letter. If the function is single-valued, then the value of the function is represented by following the function name by the proper number of arguments (see Section 3.8, “Function Definitions” for the definition of function) separated by commas and enclosed in parentheses. Thus, ADD51., COS., POLY., and FUNCT3. are function names, while ADD51. (X,Y,ADD.), POLY. (N, VJ, 7) and COS. (X) are values of functions.

The following arithmetic operations are available:

Arithmetic expressions are defined inductively as follows:

The following Boolean, or logical, operations are available in the language (where M and P are boolean expressions):

Thus, .NOT., .OR., .AND., .THEN., AND .EQV. correspond to the usual logical operations, ~, ∨, ∧, ⊃, and ≡.

Boolean expressions are defined inductively as follows:

Examples of Boolean expressions are: (X .G. 3 .AND. Y .LE. 2) .OR. (GAMMA .L. EPSILN), and ((P .AND. Q) .THEN. Q) .EQV. (P .OR. .NOT.P), where P and Q are Boolean variables.

Parentheses are used in the same way as in ordinary algebra and logic to specify the order of the computation. Also, certain conventions are used to allow deletion of parentheses. The conventions used here are the same as in ordinary algebra and logic, namely: Parentheses may be omitted, subject to the rules (A) and (B) below, but redundant parentheses are allowed.

(A) Within any expression the sequence of computation, unless otherwise indicated by parentheses, is:

Examples:

(B) Within an expression operations appearing on the same line of the list in (A) are to be performed from left to right, unless otherwise indicated by parentheses.

Examples:

The kind of arithmetic performed on a constant, variable or function value is determined by its mode. There are five modes in MAD; floating point, integer, Boolean, statement label, and function name. Floating point, integer, and Boolean constants were described in Section 1.1, “Constants”. Alphabetic constants are assumed to be of integer mode. Section 3.2, “Mode Declaration” describes how the modes of variables and functions are specified.

If an expression consists entirely of one constant, one variable, or one function value, the mode is that of the constant, variable, of functional value itself. If the expression is a compound expression; i.e., consists of two or more subexpressions joined by logical or arithmetic operations, the following rule applies:

If an expression is a Boolean expression as defined in Section 1.8, “Boolean Expressions”, then its mode is Boolean. An arithmetic expression is considered to be in the floating point mode if any operand of any arithmetic expression in the expression is in the floating point mode. If all operands are integer (or alphabetic), then the expression is considered to be in the integer mode. In this determination arguments, though not values, of functions are ignored.

Thus, if Y, Z, and W are floating point variables, while the function GCD. and the variables I and J are in the integer mode, then the expressions

are all floating point expressions while the expressions

are all integer expressions.

If an expression has subexpressions of different modes, a conversion may be necessary before some of the operations can be performed. Thus, in the expression

Y + 3

if Y is in the floating point mode it cannot be added directly to the integer 3. But for one precaution the user need not be concerned with this since the instructions necessary for the conversion of the integer to floating point form before adding are automatically inserted by the translator during the translation process. The precaution is that if the integer being converted is greater than 134,217,728 (i.e. 2²⁷) then an improper conversion will take place.

In some cases, however, the user must understand the sequence in which the conversions will be made. Consider the expression

( Y + 7/3) + (I * J/K)

where Y is in the floating point mode, and I, J, and K are in the integer mode. According to the parenthesizing conventions, the computation will proceed in the following order (where the T's are temporary locations):

and T₅ will be the value of the expression.

Now, since both I and J are integers, the first multiplication will be integer multiplication, and T₁ will be an integer. Since the following involves two integers, it will be integer division, and, if K happens to have a larger value than T₁ the quotient is 0. Similarly, T₃ will have the value 2 because of the division of two integers. In the computation of T₄, however, we have "mixed modes", since Y is floating point and T₃ is integer. There I₃ will be automatically converted to floating point before adding. Likewise, in the next step, the integer T₂ will be converted to floating point before adding to the floating point number.

In other words, although the mode of the expression is floating point because of the presence of the floating point variable Y, some of the computation (until Y is involved) is performed in integer arithmetic, and this may occasionally cause the final value to be different from the value one might expect from a different analysis.

In the example above, the divisions would be performed in the floating point mode if the expression were written:

(Y + 7./3) + (I * J)/(K + 0.)

Of course, many times the expression will be written as originally stated just to achieve the "truncation" effect.

A statement label (appearing in the label field of a statement) is a constant of statement label mode. A function name with no arguments (e.g. SIN.) is a constant of a function name mode. A single constant, variable, or function value of statement label (function name) mode is an expression of statement label (function name) mode. There are no other expressions of statement label (function name) mode. If A and B are both statement label (function name) expressions then A.E.B. and A.NE.B are Boolean expressions except when A or B are elements of a vactor which has been preset by a VECTOR VALUES statement (see Section 3.7, “Presetting Vectors”). In this exceptional case A.E.B. and A.NE.B are not expressions.

Any arithmetic expression may be used as a subscript expression for an element of a linear array. If the value of the expression is in the floating point mode (see Section 1.10, “Mode of Expressions”), it is truncated to integer form before being used as a subscript. The expressions for subscripts of elements of an array whose dimension is two or greater must be of integer mode. Moreover, for arrays of dimension three or greater the use of subscripts having other than integer mode will not be caught as an error. Subscript expressions may contain variables with subscripts, etc.

Examples of subscripted variables: J(3), K10(Z + 5 * XY/T), MP(A, B + 6 * J, I * 6/TDX), MA(K(Z + 5) + T(1) + 6).

This statement has the form illustrated by

ALPHA = Y + Z + F.(X, Y, Z)

That is, the left side of the "=" sign consists of the name of a variable (either an individual variable or a subscripted array variable), and the right side consists of any expression of the same mode. The only exceptions to this mode requirement are the cases: (1) If the variable on the left is of integer mode then the value of a floating point expression of the right will be converted to integer mode. (2) if the variable on the left is of floating point mode then the value of an integer expression on the right will be converted to floating point mode.

The substitution statement is to be interpreted as "(1) Compute the value of the expression on the right, (2) convert it, if necessary, to the mode of the variable on the left of the "=" sign, and (3) give the variable on the left the value which results from steps (1) and (2)." (See Section 1.10, “Mode of Expressions” for mode of expressions.)

Thus, if Y is a floating point variable, then the statement

Y = 1

will cause the integer 1 to be converted to floating point and then stored in the location called "Y"; i.e., Y will now have the value 1. (as a floating point number). If the statement were written

Y = 1.

then the floating point number 1. would be stored in the location "Y"; i.e., Y would again have the floating point value 1., but in this case the conversation of the integer is unnecessary, thus speeding up the computation.

When a floating point number is to be converted to an integer, it is first expressed as a number with both an integer part and a fractional part, and then the fractional part is truncated. Thus, the following floating point numbers:

3E5, .3E0, .34568127E2, - .345681E10

would convert to the following integers, respectively:

300000, 0, 34, -3456810000.

This statement has the form: TRANSFER TO S

Here S may be any statement label or any expression in statement label mode which labels an executable statement. Execution of this statement causes the computation to continue from the statement whose label is the value of S. Examples: TRANSFER TO SUMX, TRANSFER TO SWTCH (K + 2) (if K=4 then the value of SWTCH(K+2) is SWTCH(6)).

There are two types of conditional statements.

(a) Simple Conditional

WHENEVER B,Q

Here B is a Boolean expression and Q any executable statement except the following: end of program, another conditional, iteration, and function entry. If at the time of execution of this statement, the expression B has the value 1B, the statement Q is executed. If, however, B=0B, then Q is skipped and computation continues from the next statement in sequence. The comma in this statement, as in other statements containing punctuation, must be written.

Examples:

WHENEVER XM.LE.1, TRANSFER TO END WHENEVER I.GE.N.AND.J.NE.I-1, I=0

(b) Compound Conditional

        S1        WHENEVER B1
        
                ...
                ...        Θ1
                
        S2        OR WHENEVER B2
                ...
                ...        Θ2
                ...
                ...
        Sk        OR WHENEVER Bk
                ...
                ...        Θk
        Sk+1        END OF CONDITIONAL

Often the last condition B_k is always true. This may be expressed by the statement

OR WHENEVER 1B

or alternately the statement

OTHERWISE

The S_i are statement labels which need not be used unless desired. k may equal one (if no "OR WHENEVER..." statements are used). Here B₁, ..., B_k are Boolean expressions, and the execution of this block of statements is as follows.

Each B₁ is tested in turn, starting with B₁. It B₁ has the value 0B, then B₂ is tested, etc. As soon as some expression, say B_j, has the value 1B, then the statements between (but not including) S_j and S_j+1 (i.e. Θ_j) are executed. At this point the execution of the entire block is considered ended, and computation continues from the first statement after the declaration labelled S_k+1. In other words, at most one of the alternative computations is performed; e.g., that one which immediately follows the first expression B₁ which has the value 1B. If none of the B_i has the value 1B, none of the computation in the scope of these statements is performed.

Example: The evaluation of the function whose graph is

might be given by the section of the program:

WHENEVER X .LE. 0. .OR. 1. .LE. X .AND. X .L. 2. .OR. X .GE.3
 Y = 0.
OR WHENEVER 0 .LE. X .AND. X. .L. 3.
 Y = 1.
END OF CONDITIONAL

This section of program could be rewritten in another way.

WHENEVER 0. .LE. X .AND. X .L. 1.
Y = X
OR WHENEVER 2. .LE. X .AND. X .L. 3.
Y = 1.
OTHERWISE
Y = 0.
END OF CONDITIONAL

The indentation of the statements between the conditional statements is not required but contributes to the readability.

This statement has the simple form:

CONTINUE

It serves as an entry point in the program, and causes no computation to be performed by its presence or absence.

The following program segment illustrates the use of this statement.

   .
   .
   .
A = D(1, 1)
THROUGH ST1, FOR I = 1, I .G. 10
THROUGH ST1, FOR J = 1, J .G. 10
WHENEVER A .LE. D(I, J), TRANSFER TO ST1
K = I
L = J
    ST1 CONTINUE
   .
   .
   .

This statement causes the block of statements which follows immediately afterwards to be repeatedly executed, each time varying the value of some variable, until the specified list of values for that variable is exhausted, or until some specified condition is satisfied. The THROUGH statement may take either of the following two forms.

(a) THROUGH S, FOR VALUES OF V = E₁, E₂, ..., E_m

Here S is the statement label of the last executable statement in the block to be repeated. The block of statements following (and not including) the THROUGH statement, up to and including the statement whose label is S, will be called the "scope" of the THROUGH statement. Following the word OF appears the name of the iteration variable (in the illustration: V), which may be either an individual variable or subscripted array variable of any mode. To the right of the "=" sign may appear any number of expressions E₁, ... E_m. The modes of the E₁ bear the same relationship to the mode of V as they would in the statement V = E₁ (see Section 2.1, “Substitution Statement”).

The execution of this statement causes the statements within its "scope" to be executed, first with V = E₁, then again with V = E₂, and so on, until the list of expressions is exhausted. Computation then proceeds with the statement immediately following statement S. At this time the iteration variable will have the value of the expression E_m unless its value was changed during the final iteration. An example of this type of statement is:

	THROUGH A, FOR VALUES OF BETA = 3, 4, X5, Y(6 + I) + 3
	J = 5 = BETA + 6
	J1 = J .P..5 - 1
   A    X(BETA) = J1 * COS.(2. * THETA)

(b) THROUGH S, FOR V = E₁, E₂, B

Here S is a statement which defines the "scope" exactly as in (a) above (with the exception: If S is the label of the THROUGH statement itself, the iteration will proceed as described below, but the scope will be empty, and the iteration will consist only of the incrementing of V by E₂ and the testing.) Following the word FOR is the name of the iteration variable (in the illustration: V), which may be an individual variable or subscripted array variable of any mode. The modes of E₁ and E₂ are subject to the rules which would apply to the statements V = E₁ and V = V + E₂. B is a Boolean expression.

The execution of the statement proceeds as follows: The variable V is set equal to E₁. If the value of B = 1B, the scope of the THROUGH statement is not executed. If the value of B = 0B, the scope is executed. V is then incremented by E₂, and B is tested again. In general, as soon as B = 1B, the scope is not executed, and the computation proceeds from the statement immediately following statement S!. Each time B = 0B, the statements in the scope are executed, then V is incremented by E₂, and B is tested again. Thus, when the iteration is finished and B = 1B, V has the value used during the last computation of the scope, incremented by E₂. The scope will not have been executed for this value of V. (The value of V will be E₁, of course, if B = 1B before the scope is executed at all.) If, at any time, the computation transfers out of the iteration to another part of the program, the value of V will be the current value at the time the transfer was made.

In all cases, every reference to an expression E₁ will involve its current value at the time of reference. Moreover, the variable V may have its value changed at any time during the execution of the scope. In a statement of the form (a), the value of V will be reset by the value of the next E₁ for the next computation of the scope. In a statement of form (b), the current value of V will be used for incrementing, testing, etc.

Examples:

(i) To evaluate the polynomial c_nxⁿ + c_n-1xⁿ⁺¹ + ...+ c₁x + c₀ using the formula (...((c_nx + c_n-1)x + c_n-2)x + ...+ c₁)x + c₀ (nested multiplication), we may write the program:

	INTEGER J,N
	Y = 0
	THROUGH POLY, FOR J = N, -1, .L. 0
  POLY  Y = X * Y + C(J)

(For the meaning of the statement INTEGER J,N see Section 3.2, “Mode Declaration”).

(ii) A Newton's Method solution (X_k+1 = x_k - f(x_k)/f'(x_k)) of the equation f(x) = cos x - x = 0 could be written as a single statement, using the criterion "|f(x)| < ∊ and |x_k - x_k+1| = |f(x_k)/f'(x_k)| < | ∊" for stopping the iteration:

  NEW	THROUGH NEW, FOR X = X0, (COS.(X)-X)/(SIN.(X) + 1.),
  	1	.ABS.(COS.(X) - (X) .L. EPSLON .AND.
	2	.ABS.(COSX.(X) - (X)/(SIN.(X) + 1.) ) .L. EPSLON

where X0 is the initial guess.

(iii) If the transformation of the iteration variable is to be performed within the scope of the iteration, one may use a zero increment. E.g., if J is an integer variable, and the scope of the iteration is to be performed for those multiples of 2 which are not multiples of 5 and which are less than the value of the integer K, one might write the iteration as follows:

	THROUGH END, FOR J = 2, .GE. K
	...
	...
	J = K J + 2
END	WHENEVER J .E. (J/5) * 5, J = J + 2

(iv) A table-look-up procedure using an interation statement. Suppose that a string of alphabetic (or numeric) characters (i.e., a "sentence") has been decomposed into single characters stored in C(1), C(2), ..., C(K), where K is the length of the string. Then the first occurrence of a comma could be found as follows:

LOOK	THROUGH LOOK, FOR I = 1, 1, C(I), .E. $, $ .OR. I .G. K
	WHENEVER I .G. K, TRANSFER TO NOCOMA		

As indicated in Section 2.5, “THROUGH (Iteration) Statement”, the "scope" of an iteration statement is the block of statements designated for repeated execution, indicated by ... below:

	THROUGH END, FOR V = E1, E2, B
	...
	...
END	...

Some of the statements within the scope of an iteration may, themselves, be iteration statements. However, if iteration statement b is in the scope of iteration a, then the scope of b must be entirely within the scope of a. The following diagrams represent some valid configurations:

(1)                              THROUGH K, FOR ... (Iteration Statement a)
          ┌────────────────────────────────
          │
Scope     │                      THROUGH M, FOR ... (Iteration Statement b)
of a      │               ┌────────────────     ...
          │   Scope of    │                     ...
          │               │                     ...
          │      b        │                     ...	      
          │               │                     ...	      
          │               └────────────────     ...	      
          │                                     ...	      
          └────────────────────────────────     ...	      
							      
							      
                                 THROUGH K, FOR ... (Iteration  a)
          ┌────────────────────────────────		      
 (2)      │						      
          │                      THROUGH K, FOR ... (Iteration  b)
Scope of  │               ┌────────────────     ...	      
          │   Scope of    │                     ...	      
   a      │               │                     ...	      
          │      b        │                     ...	      
          │               │                     ...	      
          └───────────────┴────────────────     ...	      
							      

Here, although the scopes of a and b both end on statement K, iteration b is incremented and tested first. Therefore, iteration b is completed before iteration a is incremented:

(3)
                                 THROUGH K, FOR ... (Iteration a)
          ┌────────────────────────────────
          │
          │                      THROUGH M, FOR ... (Iteration b)
          │               ┌────────────────     ...
          │   Scope of    │                     ...
          │      b        │                     ...
          │               └────────────────     ...
          │                                     ...	      
          │                      THROUGH N, FOR ... (Iteration c)
          │               ┌────────────────     ...	      
          │   Scope of    │                     ...	      
          │      c        │                     ...
          │               └────────────────     ...
          │                                     ...
          └────────────────────────────────     ...

The following diagram represents an invalid configuration:

(4)
                                 THROUGH K, FOR ... (Iteration a)
                Scope of  ┌────────────────
           	       	  │
                    a     │      THROUGH M, FOR ... (Iteration b)
          ┌───────────────┼────────────────     ...
          │               │                     ...
Scope     │               │                     ...
of b      │               │                     ...
          │               └────────────────     ...
          │                                     ...
          └────────────────────────────────     ...

When iteration statements occur in the scope of other iteration statements, they are said to be "nested". The "nesting depth" of an iteration statement is the number of iteration statements in whose scope it appears. The nesting depth of an iteration may not exceed 50. For example:

(5)                                  THROUGH K, FOR ... (Iteration a)
          ┌────────────────────────────────────────
          │
          │                          THROUGH M, FOR ... (Iteration b)
          │               ┌──────────────────────── ...
 Scope of │   Scope of    │                         ...
    a     │      b        │          THROUGH N, FOR ... (Iteration c)
          │               │ Scope  ┌─────────────── ... 
          │    	          │ of c   │                ...
          │               │        └─────────────── ...
          │               │                         ...
          │               └──────────────────────── ...
          │                                         ...
          └──────────────────────────────────────── ...

In example (5), iteration a has a nesting depth 0, iteration b has nesting depth 1, and iteration c has nesting depth 2. In example (3), both b and c have nesting depths of 1.

There are no restrictions on jumping into or out of the statements in the scope of an iteration.

PAUSE NO. n

This statement indicates a breakpoint in the program, and it causes the computer to stop in such a way that the operator can manually start it and automatically go on to the next statement in the program. The number n is an octal integer containing up to 5 digits, which will be displayed on the computer console for the operator to note when the computer stops, thus indicating the point in the program at which the stop occurred.

Normally, the value of a function will occur as part of an expression, as in the statement:

Z = COS.(X)/SIN.(X + 2.)

Certain functions, however, may stand alone as separate statements, as a statement calling for the sorting of a list, etc. This would appear as:

EXECUTE LSORT.(ARRAY, MAP, N)

(See Section 3.8, “Function Definitions” for definition of functions). Here ARRAY, MAP, N are the "arguments" of the function (subroutine) LSORT. Arguments and parentheses may be omitted in an EXECUTE statement if the function has no arguments.

Provision is made for including an error return in function definition programs (see Section 3.8, “Function Definitions”). The form of the statement is simply:

ERROR RETURN

(An example of its use is shown near the end of Section 3.8.3, “Internal and External Functions”).

In order to use it in a function evaluation, the last (right-most) argument of the function must be the label of a statement or a variable in statement label mode, whose value is the label of a statement to which a transfer is made in case the ERROR RETURN statement is executed.

Even though an error return has been provided in the definition of a function, in the use of the function the last argument may be omitted. If it is omitted, execution of the ERROR RETURN statement will cause control to be transferred to the operating system in which the translated program is imbedded, with an error indication.

This statement has the form: END OF PROGRAM.

This statement must be the last statement in the program, both physically (i.e., the last card) and in the sequence of computation. Execution of this statement will transfer control to the operating system in which the translated program is imbedded. An alternate way of terminating a program - i.e., returning to the operating system - is to attempt to execute an input statement when the data has been exhausted.

FUNCTION RETURN N

This statement is used in a function definition to indicate a return to the calling program. N is an expression whose value is to be the output of this function considered as a single valued function. N need not be specified if outputs are specified in the argument list (see Section 3.8, “Function Definitions”).

Entry points to a function being defined are indicated by

ENTRY TO N

where N is the name of this entry (see Section 3.8, “Function Definitions”).

These statements facilitate the writing of recursive internal and external functions. (see Section 3.8, “Function Definitions”) They cause the designation and use of a vector for the temporary storage of data and action transfer instructions. (i.e. function returns).

In this section the follwing definition the following definitions will hold. B is the location of a format specification vector (see Section 2.15, “Format Specifications”) which must be an integer variable name. N is an expression whose value is to be either a tape number or a drum number. L is an input-output list. Elements of L may be: 1) single variable names or array names with subscripts;, 2) blocks of the form A(i_i, ..., i_n) ... A(j_i, ...j_n) where the i's and j's may be any subscript expression and n ≥ 1. In addition, when L designates an output list, the elements of L may be: 3) constants or 4) expressions. Elements of a list are separated by commas. Example of an output list: AB, D, 2.5, MTX(1) ... MTX(N), P(14), J(I, K). Example of a list which may be ysed either for input or output: A, B, K(3), J(25*I - L), A(K+1)... A(L*2). To completely understand the operation of statements which make an explicit reference to "TAPE" or "DRUM" it is advisable to read the sections of the IBM 704 Reference Manual which describes the operation of these units (See Restrictions below).

When information is read from (or punched in) a card into (or from) a computer, it is necessary to know how this information has been allocated among the available columns of the card. Similarly, whenever information is to be printed by a printer (either on-line of off-line), it is necessary to know how this information has been allocated among the columns available on the printer. A description of each allocation is called a format specification. Usually, but not always, such a specification is accompanied by a list of variables whose values are to be printed or punched or whose values are to be read. (Occasionally, the information is contined entirely in the format specification, so the list may be empty.) A format specification is a string of alphabetic characters (as described below) terminated by an "*". This string is stored six characters per computer word in a vector with integer mode. This vector may be preset (see Section 3.7, “Presetting Vectors”), computed, or read in as data.

S16, 6HBETA =I2*

A remark declaration consists of any string of characters acceptable to the computer. This statement is completely ignored by the translator, and furnishes information to the reader of the program. Every card of the remark declaration must have an "R" in column 11.

All variables and function values are assumed to have the normal mode unless declared otherwise. Any of the other modes may be specified as the normal mode by writing the following declarations:

NORMAL MODE IS M

where M is one of the following phrases; INTEGER, BOOLEAN, STATEMENT LABEL, FUNCTION NAME, or FLOATING POINT. Only one such declaration may appear in a program and it is in effect for the whole program, no matter where it occurs in the program. If a variable or function value is to have a mode different from the normal mode then its modes must be declared in a declaration of the following form:

M V, L, ..., F., ..., BFN.

where M is one of the phrases; INTEGER, BOOLEAN, STATEMENT LABEL, FUNCTION NAME, or FLOATING POINT; for example, BOOLEAN P,Q,DIGIT.TRUTH. Following M is the list of variables and functions whose values are to be of mode M. A program may contain any number of such mode declarations but a name may not be declared to be of two different modes.

All constants are automatically assigned modes by the translator (see Section 1.1, “Constants” ). Other automatic assignments of modes are:

Variables may be declared to be array variables, such as vectors or matrices of various dimensions, rather than individual variables.

Each array is stored in a region whose elements may be referred to by means of a single subscript, such as A(0), A(1), B(16), etc. Even elements of higher dimensional arrays may be referred to in this way at any time. We shall call the subscript thus associated with each element of an array its "linear subscript." If A is an array then the name A is equivalent to A(0), e.e., the name A written without a subscript is assumed to have a subscript of zero.

Two dimensional matrices are stored internally by rows, i.e., an m × n matrix will be stored in the order: a₁₁, a₁₂, a₁₃, ..., a_1n, a₂₁, ..., a_2n, ... a_mn. In general, matrices are stroed in the order determined by varying the right-most subscript first, then the next right-most, etc. Thus, an m × n × p × q matrix would be stored in the order: a₁₁₁₁, a₁₁₁₂, ..., a_111q, a₁₁₂₁, a₁₁₂₂, ... a_112q, ..., a_11pq, a₁₂₁₁,..., a_1npq, ... a_mnpq.

Elements of higher dimensional arrays may be referred to not only by their linear subscripts but also by the usual matrix notation, such as A(1,1), A(I,J), B(I+6,J/3+3).

Although any number of dimension declarations may be used in a program, as many variables as desired may be "declared" in any dimension declaration. The declaration consists of the word DIMENSION, followed by the variables to be declared. Each variable is immediately followed by one or two arguments (separated by a comma) enclosed in parentheses, as follows:

The first argument is a positive integer constant, specifying the largest linear subscript which an element of the array is expected to assume during the execution of the program. The size of the region allocated is this number plus one, regardless of whether the program actually makes use of this amount or not.

The second argument, given only for arrays with dimension n > 1, is the name of the first element in the "dimension vector" for this array. If this name is D(k) (k must be an integer constant), the vactor D is automatically assigned integer mode. D may not be declared to be other than integer. In addition, D must itself be dimensioned, either by declaration or by presetting its values (Section 3.7, “Presetting Vectors”) to have its largest linear subscript ≤ k+n. Assuming that elements of the array to be dimensioned are to be referred to as A(I₁, I₂, I_n), the elements of the linear array D, i.e. D(k), D(k + 1), ...D(k + n), must be preset (or set during computation) to the values

The lower bound of each subscript is assumed to be unity.

Thus, in the statement: DIMENSION XA(400, V), YT(300, K(3)) where V(0) = 2,V(1) = 6, v(2) = 13, K(3) = 3, K(4) = 4, K(5) = 8, and K(6) = 9, the variables XA and YT are designated as 2-dimensional and 3-dimensional arrays respectively. Considering the array element XA(I,J), the range of J may be expressed by 1 ≤ J ≤ 8 and 1 ≤ K ≤ 9. The array XA will have a storage region of length 401 set aside for it, e.g., XA(0), ...XA(400), and the 395 elements XA(6), XA(7), ..., XA(400) may also be referred to as XA(1,1), XA(1,2), ...XA(31,5) respectively. The matrix will be located at various places in the XA region depending on the value of V(1) at the time a reference is made ot a matrix element during execution of the program. Observe that this ability to vary the location of the initial array element (i.e., the array element with unit indices) within the linear array allows the effective use of negative subscripts - in spite of the fact that the defined ranges of the subscripts are positive.

Similarly, the matrix YT will have 301 locations set aside for it, although these do not all have to be used. The base element of YT, i.e., YT(1,1, 1) will correspond to the element YT(4) since K(4) = 4.

If the array is a vector, i.e., one-dimensional, a special convention is adopted. Only the first argument is given to the DIMENSION declaration. Thus, in the statement

DIMENSION V(10)

the array V is specified as consisting of the eleven elements V(0), ..., V(10). If a variable appears in more than one dimension declaration, the highest linear subscript will be used; however, the dimension vector must be the same in all occurrences. Negative subscripts are not available for vectors.

Dimensioning is automatic in two situations

(a) In case a statement label vector, say L, is used (see Section 1.3, “Statement Labels”) and n is the highest subscript used on L in the statement label field (i.e., if L(m) appears then m ≤ n), then n + 1 locations are reserved for L. L may also appear in a dimension declaration in which case the highest linear subscript is used.

(b) If part of all of a linear array is set by a VECTOR VALUES declaration the array need not appear in a dimension statement unless the maximum linear subscript implied by the initial values is not sufficiently high.

This declaration has the form

EQUIVALENCE (A,B), (MATRIX, XARRAY), (C, D(3))

and implies that the variables A and B are to represent the same storage location throughout the program, that MATRIX and XARRAY are to represent the same storage location through the program, etc. (Two variables which represent the same location always have the same value at any given time.) Thus, any number of equivalences may be established by one EQUIVALENCE declaration, and any number of such declarations may occur (at any place) in a program. They will be treated as one combined declaration, however.

Variables whose names appear within the same set of parentheses need not have the same mode. The mode must be established by the appropriate MODE declaration for each of the variables. Occurrences within an EQUIVALENCE declaration do not establish mode.

A nonsubscripted array variable name in an EQUIVALENCE statement represents that element of the array (considered as a one-dimensional vector) whose subscript is zero. Reference in an EQUIVALENCE statement to an array element of any number of dimensions may be made by linear-subscript only (i.e., as an element of a vector). Note that occurrence of any elements from any two arrays in the same perentheses implies equating the entire arrays accordingly.

This declaration has the form

ERASABLE MATRIX, XARRAY, YARRAY

and implies that the arrays and individual variables listed after the word ERASABLE (which need not have the same number of dimensions) are disjoint (i.e., non-overlapping in storage), but are assigned to a special section of storage which is separate from the usual storage of variables and arrays. Each ERASABLE declaration eliminates the effect of previous assignments to this special section of storage, thus allowing several arrays to occupy the same storage at different times. It should be understood that this storage is accessible to, andmay be used by, subroutines.

This declaration has the form

PROGRAM COMMON MATRIX, X, Y1, BC

and implies that the arrays and individual variables listed after the words PROGRAM COMMON (which ned not have the same number of dimensions) are disjoint (i.e., non-overlapping in storage), but are assigned to a special section of storage which is separate from the usual storage of variables and arrays, and separate from ERASABLE storage (see Section 3.5, “ERASABLE Declaration”).

One use of this statement provides for several sections or a program to refer to variables and arrays by the same names, while being translated and checked out separately. A program divided up this way would have the form of a main program and several external function programs, with the main program being used primarily to call on each of the external functions in turn. Although variables and arrays to be used jointly by several external functions can be communicated as arguments to the functions, assigning them to PROGRAM COMMON makes them available to all sections.

Note that storage is actually reserved for PROGRAM COMMON only in the main program (not in external functions, although the proper address assignment occurs there, also). Any such declarations occurring in external function definitions must therefore occur also in the main program.

Another use for the PROGRAM COMMON assignment is in the case of a segmented program, i.e., a program so large that it is written in blocks which will occupy the same section of storage and be brought in one at a time. If one block of a program is to use the results of the previous block's computation, the variables involved should be specified as being in the PROGRAM COMMON region. Then they will not be destroyed in the process of bringing in the new block of program. The PROGRAM COMMON and DIMENSION declarations which set up this storage allocation must be identical in all blocks in which these arrays and variables are to be used, except that later segments may add additional names at the end of the list .

PROGRAM COMMON declarations do not affect variables and arrays which have already been assigned to this common section of storage. If another such statement occurs in a program, the arrays and variables listed therein are considered appended to the previous list of PROGRAM COMMON arrays and variables. If a program is broken up into a main program and several external functions, the main program must be loaded into the computer first if PROGRAM COMMON is used at all.

Any vector or portion of a vector (or array when considered as a vector, i.e., using linear subscripts) may be preset by a declaration of the following form:

(a) VECTOR VALUES V = c₀, c₁, ... c_L

Here V is of the form N(n) or simply N, if n = 0. The elements N(n), ... N(n + L) are preset to the values c₀, c₁ ..., c_L, where the c_i may be any constants. N is automatically set to have the same mode as c₀ and given a storage reservation of n + L + 1 locations, i.e., this is equivalent to writing DIMENSION N(N + L). N may appear in a mode declaration provided it is consistent with the mode of c₀. If N appears in other VECTOR VALUES or DIMENSION declarations the maximum length given or implied for N is used for storage assignment. The c₁ must all be of the same mode.

(b) VECTOR VALUES V = $ k₁ ... k_m$, $k_m+1... k_p$, ...

Here the k_i may be any valid characters (including blanks but excluding "$") and L (used as in (a) above) is equal to the smallest integer ≥ m/6.

This declaration is useful for presetting dimension vectors and and format descriptions. The presetting is done at the time of translation. The constants c_i are loaded (as part of the translated program) into V. This declaration produces no computation at execution time. However, the values of V may be modified by other statements in the program during execution.

Vectors which have been assigned to ERASABLE storage (see section Section 3.5, “ERASABLE Declaration”) may not be preset by a VECTOR VALUES statement. Vectors which have been assigned to the PROGRAM COMMON section of storage (see section 3.6) can be preset with numerical or alphabetical information only (not statement labels or function names) and then only if it is a single section program (i.e., storage is loaded with instructions only once) or, if it is a multiple section program, the PROGRAM COMMON region is identical in all sections of the program.

There are two main types of functions: The internal function and the external function. Since these are quite similar in many ways, that part of the description which is specific to external functions will be given in Section 3.8.1, “External Function Definitions”, that which is specific to internal functions in Section 3.8.2, “Internal Function Definitions”, and that which is common to both types will follow in subsection Section 3.8.3, “Internal and External Functions”. Throughout this section a single-valued function will be called a "function", and a function with multiple outputs and/or multiple exits will be called a "procedure". For the purposes of this manual a recursive function is one whose definition contains calls for the function being defined -- or calls for functions which ultimately call the one being defined. Recursive functions have the same structure as other functions although, in general, they will include statements of the type described in Section 2.13, “List Manipulation Statements”, and certain considerations should be borne in mind when constructing such functions. These considerations arise from the fact that names, instead of values, are used as function arguments. The problem is considered in more detail in the examples in Chapter III.

INTERNAL FUNCTION (X)
ENTRY TO COS.
...
...
...
ENTRY TO SIN.
...
...
...
FUNCTION RETURN ALPHA + J - 3
ENTRY TO TAN.
...
...
...
FUNCTION RETURN BETA/K5 - 4 * D
END OF FUNCTION

EXTERNAL FUNCTION (M, N, I, P, Q)
STATEMENT LABEL N, I
...
...
...
FUNCTION RETURN
...
...
...
WHENEVER B, TRANSFER TO I
...
...
...
TRANSFER TO N
END OF FUNCTION

      A EXTERNAL FUNCTION (X)
      J ENTRY TO INVSF.
      G WHENEVER X.G.0 .AND. X .LE. 1
      C    FUNCTION RETURN X .P. -1
      H OR WHENEVER X .G. 1
      D    FUNCTION RETURN X .P. -2
      I OTHERWISE
      E    ERROR RETURN
      K END OF CONDITIONAL

      B END OF FUNCTION

         A = B - D
         Z = T(I) + INVSF.(Y) *T(I-1)
         Y(I) = Z + R(J) * 2.5

	A = B - D
     F  Z = T(X) + INVSF.(Y, ER)* T(I-1)
     S Y(I) = Z = R(J) * 2.5
     	...
	...
    ER  Z = 0
    L   Y(I) = 1.
    	...

Problem: To solve the quadratic equation ax² + bx + c = 0 for various sets of coefficients a, b, and c.

Analysis: Let x₁ and x₂ be the two roots of the equation. Then their values are found by the formulas,

whenever a ≠ 0. The single root x₁ of the equation when a = 0 is x₁ = -c/b. The input values of a, b, and C are printed immediately after they are brought in to help in finding trouble spots during the development of the program (not as necessary here as in longer problems, but a good idea!).

Flow Diagram:

The Program:

          R
          R MAIN PROGRAM
          R
GAMMA       READ FORMAT INPUT,A,B,C
            PRINT FORMAT CHECK,A,B,C
            WHENEVER A .NE. 0,TRANSFER TO ALPHA2
ALPHA1      PRINT FORMAT LINEAR,-C/B
            TRANSFER TO GAMMA
ALPHA2      D = B .P.2 -4.*A*C
            WHENEVER D .L. 0, TRANSFER TO BETA2
BETA1       PRINT FORMAT REAL,(-B+SQRT.(D)/(2.*A)),(-B-SQRT.(D)/(2.*A))
            TRANSFER TO GAMMA
BETA2       PRINT FORMAT COMPLX,-B/(2.*A),SQRT.(-D)/(2.*A),
          1  -B/(2.*A),-SQRT.(-D)/(2.*A)
            TRANSFER TO GAMMA
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES INPUT = $ 3F10.4*$
            VECTOR VALUES CHECK = $ 4H0A = F10.4,S8,
          1 3HB = F10.4,S8,3HC = F10.4*$
            VECTOR VALUES LINEAR = $21H0LINEAR EQUATION, X =F10.4*$
            VECTOR VALUES REAL = $21H0REAL SOLUTIONS,X1 = 
          2 F10.4,S8,4HX2 = F10.4*$
            VECTOR VALUES COMPLX = $19H0COMPLEX SOLUTIONS,
          1 S4,7HR(X1) = F10.4,S8,7HI(X1) = F10.4,S8,
          2 7HR(X2) = F10.4,S8,7HI(X2) = F10.4*$
            END OF PROGRAM


*DATA
          4.          -8.          4.
          0            5.         10.
          1.           1.          1.

Problem: A logical (Boolean) expression such as (P .AND. Q) .OR.(.NOT. P .AND. R .AND. S).OR.(R .OR. P) will have a value TRUE or FALSE (represnted here by 1B and 0B, respective­ly) depending on the "input values" of the variables involved: P,Q,R,S. Thus, if P = 1B, Q = R = S = 0B, then the total expression T will have the value 1B. The entire table of outputs for all possible inputs would be as follows:

The problem is to write a program to generate the entire "truth table" for the given expression T.

Flow Diagram:

The Program:

            PRINT FORMAT HEADER
            BOOLEAN P,Q,R,S
            THROUGH A, FOR VALUES OF P = 0B,1B
            THROUGH A, FOR VALUES OF Q = 0B,1B
            THROUGH A, FOR VALUES OF R = 0B,1B
            THROUGH A, FOR VALUES OF S = 0B,1B
A           PRINT FORMAT TABLE,P,Q,R,S,(P .AND. Q) .OR.(.NOT. P .AND. R
          1 .AND. S).OR.(R .OR. P)
            VECTOR VALUES HEADER = $1H1,S10,1HP,S10,1HQ,S10,1HR,S10,1HS,
          1 S15,1HT*$
            VECTOR VALUES TABLE = $1H0,4(S10,I1),S15,I1*$
            END OF PROGRAM

Note: Although it would have meant only a slight change in the format information, no attempt was made here to label the "0" and "1" that print as values in the table as Boolean, i.e., "0B" and "1B". This points up the fact that internally 0B and 1B are stored as 0 and 1, respectively. Also, the statement

NORMAL MODE IS BOOLEAN

could have been used as tthe second statement of this program instead of the BOOLEAN declaration.

Problem: To approximate _a∫^b f(x) by Simpson's Rule, for an arbitrary interval [a, b] using N equal subintervals (where N is an arbitrary even integer).

Analysis:By Simpson's Rule

where y_i = f(x_i), and a = x₀, x₁, ... x_N = b are the partition points of the interval [a,b].

Method: We shall write the program in the form of an external function, so that it could be used with any other program. The evaluation of f(x) could be accomplished by another external function or an internal function.

Flow Diagram:

The Program:

            EXTERNAL FUNCTION (A,B,N,F.)
            INTEGER N
            ENTRY TO SIMPS.
            H = (B-A)/N
            S1 = 0
            S2 = 0
            THROUGH ALPHA,FOR X = A+H, 2.*H, X .G. B
            S1 = S1 + F.(X)
ALPHA       S2 = S2 + F.(X+H)
            FUNCTION RETURN H*(F.(A)+4.*S1+2.*S2-F.(B))/3
            END OF FUNCTION

If, for some reason, the integral of sin 3x - cos(rx + 1) were needed if 0 ≤ x ≤ 3, and the integral of sin 3x - cos(rx) otherwise, the program might then be as follows:

The Program:

READ        READ FORMAT INPUTS,A,B,N,R
            INTEGER N
            WHENEVER 0. .LE. R .AND. R .LE. 3
            PRINT FORMAT RESULT,A,B,N,R,SIMPS.(A,B,N,F1.)
            OTHERWISE
            PRINT FORMAT RESULT,A,B,N,R,SIMPS.(A,B,N,F2.)
            END OF CONDITIONAL
            TRANSFER TO READ
          R
          R DEFINITION OF FUNCTIONS
          R
            INTERNAL FUNCTION F1.(X) = SIN.(3.*X)-COS.(R*X+1.)
            INTERNAL FUNCTION F2.(X) = SIN.(3.*X)-COS.(R*X)
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES INPUTS = $2F12.4,I6,F12.4*$
            VECTOR VALUES RESULT = $23H1 FOR THE INTERVAL FROM
          1 F12.4,3H TO F12.4,5H WITH I6,38H EQUAL SUB-INTERVALS AND   
          2 PARAMETER F12.4/29H0THE VALUE OF THE INTEGRAL IS F12.4*$
            END OF PROGRAM

External Functions:

            EXTERNAL FUNCTION (A,B,N,F.)
            INTEGER N
            ENTRY TO SIMPS.
            H = (B-A)/N
            S1 = 0
            S2 = 0
            THROUGH ALPHA,FOR X = A+H, 2.*H, X .G. B
            S1 = S1 + F.(X)
ALPHA       S2 = S2 + F.(X+H)
            FUNCTION RETURN H*(F.(A)+4.*S1+2.*S2-F.(B))/3
            END OF FUNCTION

*DATA
         0          2.         10          10.

An alternate way to write the first eight lines of this program, illustrating one use of the FUNCTION NAME mode, would be:

READ	READ FORMAT INPUTS,A,B,N,R
	INTEGER N
	WHENEVER 0. .LE. R .AND. R .LE. 3
	S = F1.
	OTHERWISE
	S = F2.
	END OF CONDITIONAL
	PRINT FORMAT RESULT,A,B,N,R,SIMPS.(A,B,N,S)
	TRANSFER TO READ
	FUNCTION NAME S

Problem: To find a real solution (if it exists) of the equation f(x) = 0 (where f is a continuous function) obn an arbitrary interval [a, b], provided the roots (if there are more than one) are at least ∊ apart.

Analysis: We specify a, b, and ∊ as parameters. The method used will be "half-interval convergence," in which the function is evaluated at x -a, and then the interval is scanned for a change of sign^[5] in the value of f(x). If no change odf sign is found, the scanning is repeated with a step size for searching half of the previous size. If the step size becomes smaller than ∊, and no change of sign is found, the process is terminated, and comment is printed: "NO SOLUTION".

If a change of sign is found between x_L and x_R, the value of f is computeed at x_M = (x_L + x_R)/2, i.e. the midpoint of the interval of uncertainty [x_L, x_R]. We then determine which one of the intervals [x_L, x_M]. [x_M, x_R] now contains a change in sign. We then compute the value of f at the midpoint of that smaller interval, etc., until the interval being considered finally has length less that ∊, at which time either end may be taken as the solution with an error less than ∊.

The method used here to handle the x_M cpomputation is perhaps not the most obvious one. It consists of a simple loop in which the value of x is adjusted by h′ = -h/2, then h′′ - h′/2 = h/4, etc., until h is small enough. The adjustment of x is either to the left or to the right, depending on the occurrence or non-occurrence, respectively, of a change of sign between f(a) and f(x).

It should be understood that this method may not find a root which is one of a pair of roots which either coincide or are less that ∊ apart.

Flow diagram:

Program: It is assumed here that f (referred to as F. in the program) will be defined as an internal function.)

Definition: SIGN.(Z) = Z/|Z|

            INTERNAL FUNCTION F.(Z) = Z .P. 2 - 2
PSI         READ FORMAT ABEPS, A,B,EPS
            READ FORMAT INVAL, A,B,EPS
            YA = F.(A)
            THROUGH ALPHA,FOR H = (B-A)/2.,-H/2.,H .L. EPS
            THROUGH ALPHA,FOR X = A+H,H, X .G. B
            WHENEVER F.(X) .E. 0,TRANSFER TO ETA
ALPHA       WHENEVER YA*F.(X) .L. 0,TRANSFER TO DELTA
            PRINT FORMAT NOROOT
            TRANSFER TO PSI
          R
          R THE NEXT SECTION IS ENTERED WHEN A CHANGE OF SIGN IS FOUND
          R
DELTA       THROUGH SIGMA,FOR H=H/2.,-H/2.,H .L. EPS
SIGMA       X = X+SIGN.(YA*F.(X))*H
ETA         PRINT FORMAT ROOT,X
            TRANSFER TO PSI
          R
          R DEFINITION OF SIGN. FUNCTION
          R
            INTERNAL FUNCTION SIGN.(Z) = Z/.ABS.(Z)
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES ABEPS = $ 3F12.4*$
            VECTOR VALUES INVAL = $18H1INPUT VALUES, A = F12.4,S3,
          1 3HB = F12.4,S3,5HEPS = F12.4*$
            VECTOR VALUES NOROOT = $12H0NO*SOLUTION *$
            VECTOR VALUES ROOT = $14H0SOLUTION, X = F12.4*$
            END OF PROGRAM

*DATA
          1.          2.          .01

Problem: Find the transpose A' of an n×n matrix A = (a_ij).

Analysis: If we write A' = (b_ij) then b_ij = a_ji. We shall inter­change symmetrically-placed pairs of elements, leaving untouched elements on the main diagonal. The program will be in the form of an external function.

Flow diagram:

Program:

            EXTERNAL FUNCTION (A,N)
            ENTRY TO TRANS.
            THROUGH BETA, FOR K=1,1, K .GE. N
            THROUGH BETA, FOR I = K+1,1, I .G. N
            Z = A(I,K)
            A(I,K) = A(K,I)
BETA        A(K,I) = Z
            FUNCTION RETURN
            INTEGER N,K,I
            END OF FUNCTION

Note: No dimension information is needed for A, since it is an argument in a function definition program. The function would be called with a statement of the form EXECUTE TRANS.(A, N).

Problem: Multiply the matrix A = (a_ij) by the matrix B = (b_ij) to produce the matrix X = (c_ij), i.e. C = A · B. Assume tha A has dimensions m × n with m · n ≤ 1500, B has dimensions n × p with n · p ≤ 1500, and C has dimensions m × p with m · p ≤ 1500.

Analysis: An element c_ij of C is computed by the formula

Flow diagram:

The Program:

            DIMENSION A(1500,ADIM),B((1500,BDIM).C(1500,CDIM)
            EQUIVALENCE(N,ADIM(2)),(P,BDIM(2))
            INTEGER I,J,K,L,M,N,P
            VECTOR VALUES ADIM = 2,0,0
            VECTOR VALUES BDIM = 2,0,0
            VECTOR VALUES CDIM = 2,0,0
READ        READ FORMAT INPUT,M,N,P,A(1,1)...A(M,N),B(1,1)..B(N,P)
            PRINT FORMAT INVAL,M,N,P,A(1,1)...A(M,N),B(1,1)..B(N,P)
            CDIM(2) = P
            THROUGH Q, FOR I = 1,1, I .G. M
            THROUGH Q, FOR J = 1,1, J .G. P
            C(I,J) = 0
            THROUGH Q, FOR K = 1,1, K .G. N
Q            C(I,J) = C(I,J) + A(I,K)*B(K,J)
            PRINT FORMAT RESULT,C(1,1)...C(M,P)
            TRANSFER TO READ
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES INPUT = $3I4/(6F122.4)*$
            VECTOR VALUES INVAL = $13H0INPUT*VALUES/4H0M = I6,56,3HN = I6
          1 ,S6,3HP = I6//(1H0,8F13.4)*$
            VECTOR VALUES RESULT = $9H1C MATRIXC//(1H0,8F13.4)*$
            END OF PROGRAM


* DATA
   2   3   3
          1.           2.           3.           4.          5.          6.
          7.           8.           9.          10.         11.         12.
         13.          14.          15.

Problem Solve a system of n ≤ 20 simultaneous linear equations in n unknowns, assuming that one does not encounter a zero on the main diagonal of the coefficient matrix during the solution process.

Analysis: We shall use a Jordan Elimination Method, in which each diagonal coefficient is used to "clear" all other coefficients in its column to zero by appropriate multiplications and subtractions. Since we shall divide the "clearing row" by the diagonal element in that row before clearing t;he column, we shall finish the process with only a diagonal of ones and the solution to the problem as the resulting right hand side of the equations.

We denote the system of equations to be solved by:

         a11x1 + a12x2  + ... + a1nxn = a1,n+1

(1)      a21x11 + a22x2 + ... + a2nxn = a2,n+1

           .       .             .        .
           .       .             .        .
           .       .             .        .
	an1x1  + an2x2 + ...  + annxn = an,n+1

We divide the first row by its diagnoal element a₁₁. Then to clear a₂₁ ato zero we substract a₂₁ times the first row from the second row, and so on. In general, to clear a_ik to zero (after row K has been divided by a_kk), we subtract a_ik times row k from row i (i≠k). A typical element a_ij is thus transformed each time by the formulas:

(2)      akj = akj/akk

(3)      aij = aij-aikakj  (i≠k)

where the value of a_kj in (3) is the result of (2). These transformations are performed for k = 1, 2, ..., n. For each (fixed) k, we will let i = 1, 2, ...., k-1, k+1, ..., n, so as to operate on all rows except i=k. While transforming each row we will cycle on j from right to left; i.e., j = n+1, n, n-1, ... k, and we stop at j = k since for j < k there is no change in the matrix.

The array

			a11a12 ... a1,n+1
			     .          .
			     .          .
	A = (aij)    =       .          .
			     .          .
			an1an2 ... an,n+1

is called the "matrix of coefficients" of the system (1).

It should be understood that this method, involving the assumption of no zeros on the diagonal and not searching for the largest element of a row to use as a divisor (to minimize round-off error), is not satisfactory from a mathematical point of view. It could serve as a basis for a larger, more complete program, however, and serves here only as an example problem.

Flow diagram:

The Program:

            DIMENSION A(420, ADIM)
            VECTOR VALUES ADIM = 2,0,0
DELTA       READ FORMAT NVAL,N
            ADIM(2) = N+1
            READ FORMAT INPUT, A(1,1)...A(N,N+1)
            PRINT FORMAT INVAL,N,A(1,1)...A(N,N+1)
            THROUGH B, FOR K = 1,1,K .G. N
            THROUGH C, FOR J = N+1,-1,J .L. K
C           A(K,J) = A(K,J)/A(K,K)
            THROUGH B, FOR I = 1,1,I .G. N
            WHENEVER I .E. K, TRANSFER TO B
            THROUGH D, FOR J = N+1,-1, J .L. K
D           A(I,J) = A(I,J)-A(I,K)*A(K,J)
B           CONTINUE
            THROUGH E, FOR I = 1,1,I .G. N
E            PRINT FORMAT RESULT,I,A(I, N+1)
            TRANSFER TO DELTA
            INTEGER I,J,K
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES NVAL = $ I4* $
            VECTOR VALUES INPUT = $ 6F12.4* $
            VECTOR VALUES INVAL = $7H1 INPUT//4H N = I4//
          1 7H MATRIX//(1H0,8F12.4)*$
            VECTOR VALUES RESULT = $ 1H0,S20,2HX(,I2,3H) = F12.4*$
            END OF PROGRAM


* DATA
   3
          1.           1.           1.           6.         -1.           0
          0.          -1.          -1.          -2.         -9.        -32.

Problem: Compute the social security deduction and accumulated gross pay. The program should read a card containing: (a) the employee's name, (b) his payroll number, (c) his gross pay for the current week, and (d) his accumulated gross pay for the current year (but not including item (c)). For each card read, the program should print (a) and (b) from the card, and, in addition, print (e) the updated gross pay, (f) the social security deduction for the current week, and (g) the net pay for the current week, taking into account only the social security deduction.

Analysis: The social security deduction is currently 3% of the gross pay until the accumulated gross pay for the year exceeds from $4800.00. The updated gross pay can be computed from the formula, (e) = (c) + (d). The social security deduction has already been made on (d). There are thus three cases to consider:

The information on the cards to be read will be in the following format:

The printed output will be in the following format:

Flow chart: We will use the following abbreviations:

The Program:

START       READ FORMAT IN,NAME(1)...NAME(5),PAYNR,GROSSW,AGROSY
            VECTOR VALUES IN = $5C6,I8,F6.2,F8.2*$
            DIMENSION NAME(5)
            INTEGER PAYNR, NAME
            WHENEVER AGROSY .GE. 4800,TRANSFER TO BIGGRS
            WHENEVER GROSSW+AGROSY .G. 4800.,TRANSFER TO BIGTOT
            FICA = .03*GROSSW
            TRANSFER TO UPDATE
BIGGRS      FICA = 0.
            TRANSFER TO UPDATE
BIGTOT      FICA = .03*(4800.-AGROSY)
UPDATE      UGROSY = AGROSY+GROSSW
            NETPAY = GROSSW-FICA
            PRINT FORMAT OUT,NAME(1)...NAME(5),PAYNR,UGROSY,FICA,NETPAY
            TRANSFER TO START
            VECTOR VALUES OUT = $1H0,5C6,S3,I8,S3,F8.2,S3,F5.2,S3,F6.2*$
            END OF PROGRAM


* DATA
GEORGE WASHINGTON                        12345678 100.    4800.
JOHN ADAMS                               12345679 200.    4900.
THOMAS JEFFERSON                         12345680 200.    4600.
JAMES MADISON                            12345681 200.    4700.
JOHN QUINCY ADAMS                        12345682 100.     300.

Alternate Program:

START       READ FORMAT IN,NAME(1)...NAME(5),PAYNR,GROSSW,AGROSY
            VECTOR VALUES IN = $5C6,I8,F6.2,F8.2*$
            DIMENSION NAME(5)
            INTEGER PAYNR, NAME
            WHENEVER AGROSY .GE. 4800
            FICA = 0.
            OR WHENEVER GROSSW+AGROSY .G. 4800.
            FICA = .03*(4800.-AGROSY)
            OTHERWISE
            FICA = .03*GROSSW
            END OF CONDITIONAL
            UGROSY = AGROSY+GROSSW
            NETPAY = GROSSW-FICA
            PRINT FORMAT OUT,NAME(1)...NAME(5),PAYNR,UGROSY,FICA,NETPAY
            TRANSFER TO START
            VECTOR VALUES OUT = $1H0,5C6,S3,I8,S3,F8.2,S3,F5.2,S3,F6.2*$
            END OF PROGRAM


* DATA
GEORGE WASHINGTON                        12345678 100.    4800.
JOHN ADAMS                               12345679 200.    4900.
THOMAS JEFFERSON                         12345680 200.    4600.
JAMES MADISON                            12345681 200.    4700.
JOHN QUINCY ADAMS                        12345682 100.     300.

Problem: Assume that a master tape is available containing basic information for each employee: (1) The employee number, (2) his hourly rate, (3) gross pay to date, (4) amount of withholding tax withheld to date, (5) social security deduction withheld to date, (6) net pay to date, and (7) the number of exemptions. Input will be in the form of m cards representing the current pay record, containing the employee's number and the number of hours worked during the current week. Pay is to be copmuted at time and a half for any hours worked over forty. (We shall assume that the input deck is already sorted according to increasing employee number, but we shall provide for cards which may be out of order. The last input card must have an employee number greater than the last employee number of the master tape.

The withholding tax W is to be computed by the formula:

W = .18(Gross pay = 13 n)

where n is the number of exemptions. If n is negative, we set W = 0 (see Note 2 below). The social security deduction FICA is 3 per cent of gross pay up to $4800, with no deduction for gross pay over $4800.

A program is desired which will produce a listing (for each input card) of (a) employee number, (b) gross pay this week, (c) withholding tax, (d) FICA, (e) net pay for the week. Moreover, a new updated master tape shojuld be prepared, with provision for saving the previous master tape as well. As much checking as possible should be incorporate, including specifying to the operator the number of the master tape needed, and the number to be assigned to the new tape produced by the program, and the automatic checking that the correct tape has been mounted on the unit.

Note 1: Abbreviations used here are outlined in Example 1, except for the following new terms:

Note 2: In the computations of the gross pay for the current week we shall find it useful to be able to compute a function (which we shall call EXCESS.) of two numbers, say a and b, whose value is 0 if a ≤ b, and a-b if a > b. A formula for this function is

where | | denotethe usual "absolute value". In fact, by using this function, a simple one-line formula for this function is:

FICA = .03 EXCESS.((GROSSW - EXCESS.(AGROSY, 4800.)),0)

where AGROSY is assumed to already contain GROSSW, i.e., to have been updated already. We shall also apply this function in the case of the withholding tax to guarantee that we do not make a negative deduction. Thus

W = .18*EXCESS. (GROSSW, 13*EXEMPT)

Note 3: To check the order of input cards (normally in order of increasing employee number with a large employee number greater than the last employee number on the master tape) the program uses the subroutine SETEOF.(LABEL), where LABEL is the statement label of a statement to be executed if an end of file condition is detected during reading.

Since the last input card has a large employee number the first end of file condition is normally detected at the end of processing, but an illegal input card may also exist with a high employee number. After the first end of file is detected the end of file return is changed and the input tape checked for end of file. If no end of file exists a comment is printed to change tapes and processing begins again.

Flow diagram:

The Program:

START       READ FORMAT IDENT,TAPENO
            INTEGER TAPENO,PAYNR,NUMB,J,OLTAPE
            PRINT ON LINE FORMAT OPER,TAPENO
            PAUSE NO. 1
            REWIND TAPE 4
TEST        REWIND TAPE 3
            READ BINARY TAPE 3,OLTAPE
            WHENEVER OLTAPE .E. TAPENO,TRANSFER TO MAIN
            PRINT ON LINE FORMAT WRONG
            PAUSE NO. 3
            TRANSFER TO TEST
MAIN        CUMGRS = 0.
            CUMFIC = 0.
            CUMNET = 0.
            CUMW = 0.
REDO        EXECUTE SETEOF.(M FILE)
            WRITE BINARY TAPE 4,TAPENO+1
READ(1)     READ FORMAT EMPLOY,PAYNR,HOURS
READ(2)     READ BINARY TAPE 3, NUMB,RATE,AGROSY,AWITHY,
          1 AFICAY,ANETY,EXEMPT
            WHENEVER NUMB .E. PAYNR
            GROSSW = RATE*HOURS+.5*RATE+EXCESS.(HOURS,40)
            AGROSY = AGROSY+GROSSW
            W = .18*EXCESS.(GROSSW,13.*EXEMPT)
            FICA = .03*EXCESS.((GROOW-excess.(AGROSY,4800.)),0)
            NETPAY = GROSSW-W-FICA
            AWITHY = AWITHY+W
            AFICAY = AFICAY+FICA
            ANETY = ANETY+NETPAY
            CUMGRS = CUMGRS+GROSSW
            CUMFIC = CUMFIC+FICA
            CUMNET = CIMNET+NETPAY
            CUMW = CUMW+W
            WHENEVER .ABS. (AGROSY-ANETY-AFICAY-AWITHY) .GE. .005, PRINT
          1 FORMAT ERROR,PAYNR
            PRINT FORMAT OUTPUT,PAYNR,GROSSW,W.FICA,NETPAY
            J = 1
            OR WHENEVER NUMB .G. PAYNR
            PRINT FORMAT ORDER,PAYNR
            BACKSPACE RECORD OF TAPE 3
            TRANSFER TO READ(1)
            OTHERWISE
            J = 2
            END OF CONDITIONAL
            WRITE BINARY TAPE 4,NUMB,RATE,AGROSY,AWITHY,AFICAY,ANETY,
          1 EXEMPT
            TRANSFER TO READ(J)
M FILE      END OF FILE TAPE 4
            REWIND TAPE 3
            REWIND TAPE 4
            EXECUTE SETEOF.(C FILE)
            READ FORMAT EMPLOY,DUMMY,DUMMY
            PRINT FORMAT NOMAN,PAYNR,TAPENO
            PRINT ON LINE FORMAT NOMAN,PAYNR,TAPENO
            PAUSE NO. 4
            TAPENO=TAPENO+1
            BACKSPACE RECORD OF TAPE 7
            READ BINARY TAPE 3,DUMMY
            TRANSFER TO REDO
C FILE      PRINT ON LINE FORMAT OFF,TAPENO,TAPENO+1
            PAUSE NO. 2
            PRINT FORMAT TOTALS,CUMGRS,CUMFIC,CIMNET,CUMW
            EXECUTE SYSTEM.
          R
            INTERNAL FUNCTION EXCESS.(X,Y)=(X-Y+ .ABS.(X-Y))/2.
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES IDENT = $I8*$
            VECTOR VALUES OPER =$15H4MOUNT TAPE NO. I8,S2,30HON TAPE UNI
          1 T NO. 3,PRESS START*$
            VECTOR VALUES WRONG = $48H4THE WRING TAOE HAS BEEN USED. PLEA
          1 SE TRY AGAIN.*$
            VECTOR VALUES EMPLOY = $I8,F10.2*$
            VECTOR VALUES ERROR = $37H0ERROR IN CHECKING TOTALS FOR MAN N
          1 O. I8$
            VECTOR VALUES OUTPUT = $1H0,I8,4F20.2*$
            VECTOR VALUES OFF = $24H4REMOVE TAPE LABEL 3,LABEL IT I8,S4,233HREMO
          1 VE TAPE 4, LABEL IT I8*$
            VECTOR VALUES NOMAN = $38H0THERE IS NO MASTER RECORD FOR MAN
          1 NO. I8/22H0PULL TAPE 3. LABEL IT I8/51H0RESELECT TAPE 4 AS TAP
          2 E 3 AND HANG BLANK TAPE ON 4/16H0THEN PUSH START*$
            VECTOR VALUES ORDER = $8H0MAN NO.I8,43H IS OUT OF ORDER OR NO
          1 MASTER RECORD EXISTS*$
            VECTOR VALUES TOTALS = $13H1CUM. GROSS =F10.2/12H0CUM. FICA =
          1 F10.2/11H0CUM. NET = F10.2/23H0CUM WITHHOLDING TAX = F10.2*$
            END OF PROGRAM

Problem: Mortgage Payment. The type of mortgage we consider is the fixed principle type for which each installment consists of an interest payment, a fixed amount to be deducted from the outstanding principal, and an additional amount to be placed in escrow--to be used to make insurance and tax payments.

Assume that a master card file is available containing the following information for each mortgage: (1) the mortgage number; (2) amount of outstanding principal; (3) annual payment on principal; (4) interest rate; (5) annual escrow payment; and (6) current escrow balance. There is also a file of cards available containing the current payment record consisting of mortgage number and amount of payment received. The master file and current payment file are assumed to be in order of increasing mortgage number.

The program is to read a card from the current payment record and check to see if it is acceptable. A payment is deemed acceptable if it consists of a single normal payment (i.e., a payment consisting of a single principal payment, a single escrow payment, and an interest payment for a single period) or if it consists of exactly two normal payments and any number (i=0, 1, 2, ...) of principal payments.

Note 1: Since the Michigan Algorithm Decoder uses the dollar sign as the delimiter for characters it is not possible to print out the dollar sign in a hollerith field. Using the - $=$ sets up the proper bit configuration for the dollar sign in storage since single characters appear in the left most position of the word. This character constant can be named and put on the list of items to be printed out.

Note 2: The current payments are processed until the file is exhausted. The detection of the end of file on reading tranfers control to the section of the program which punches the new master file.

Flow diagram:

The Program:

            DIMENSION RECORD(1400, DIM)
            INTEGER I, NUMB
            VECTOR VALUES DIM = 2,1,7
            VECTOR VALUES DOLLAR = -$=$
START       READ FORMAT SIZE, NUMB
            THROUGH A, FOR I = 1,1, I .G. NUMB
A           READ FORMAT MASTER,RECORD(I,1)...RECORD(I,6)
            EXECUTE SETEOF.(UPDATE)
            I = 1
CARDS       READ FORMAT PAYMT, IDENT,AMOUNT
            THROUGH B, FOR I = 1,1,I .G. NUMB
            WHENEVER RECORD(I,1) .E. IDENT
              DUE1 = RECORD(I,3)+RECORD(I,5)+RECORD(I,4)+RECORD(I,2)
              WHENEVER .ABS. (AMOUNT-DUE1) .L. .005
                RECORD(I,2) = RECORD(I,2) - RECORD(I,3)
                RECORD(I,6)=RECORD(I,6)+RECORD(I,5)
                TRANSFER TO CODE
              OTHERWISE
                DUE2 = 2.*DUE1 - RECORD(I,4)*RECORD(I,3)
              END OF CONDITIONAL
              WHENEVER .ABS. (AMOUNT-DUE2) .L. .005
                RECORD(I,2) = RECORD(I,2)-2.*RECORD(I,3)
                TRANSFER TO ESCROW
              OR WHENEVER AMOUNT .G. DUE2
                THROUGH C, FOR PAY = RECORD(I,3),RECORD(I,3),
          1     AMOUNT .L. DUE2+PAY
C               WHENEVER .ABS. (AMOUNT-DUE2-PAY) .L. .005, TRANSFER TO
          1     PAID
                TRANSFER TO OVERPAY
PAID	        RECORD(I,2)=RECORD(I,2)-2.*RECORD(I,3)-PAY
ESCROW	        RECORD(I,6)=RECORD(I,6)+2.*RECORD(I,5)
CODE	        RECORD(I,7)=1.
              OTHERWISE
OVRPAY	        PRINT FORMAT REJECT,IDENT,DOLLAR,AMOUNT
              END OF CONDITIONAL
            OR WHENEVER RECORD(I,1) .G. IDENT
              PRINT FORMAT ORDER,IDENT,DOLLAR,AMOUNT
            OTHERWISE
B             CONTINUE
              I=1
              PRINT FORMAT NONE,IDENT
            END OF CONDITIONAL
            TRANSFER TO CARDS
UPDATE            THROUGH D, FOR I=1,1,I .G. NUMBER
D           WHENEVER RECORD(I,7).G. 0.,PUNCH FPRMAT MASTER,RECORD(I,1)...
          1 RECORD(I,6)
          R
          R FORMAT SPECIFICATIONS
          R
            VECTOR VALUES SIZE=$I10*$
            VECTOR VALUES MASTER=$F10.0,5F10.2*$
            VECTOR VALUES PAYMT = $F10.0,F10.2*$
            VECTOR VALUES REJECT = $20H0PAYMENT ON MORTGAGE,F10.  ,3H,   ,C
          1 11,F10.2,19H IS UNSATISFACTORY*$
            VECTOR VALUES ORDER = $26H0PAYMENT CARD FOR MORTGAGE,F10.0,3H
          1 ,C1,F10.2,44H IS OUT OF ORDER OR NO MASTER RECORD EXISTS*$
            VECTOR VALUES NONE $1H0NO MASTER RECORD EXISTS FOR MORTGAG
          1 E NO.,F10.0*$
            END OF PROGRAM

Problem: Computation of actuarial commutation columns based on an arbitrary set of mortality rates and an interest rate, as an external function to be used by another program.

Analysis: Commutation columns, which are very important tools in actuarial problems are generated very easily by means of the formulas given below. The quantities M_x, N_x, and D_x in these formulas occur most often in combination, as in the computation of P_x. Assuming a population of some initial size (at x = b₀) (here 1,000,000), l_x is the number living a t age x (so that l_bo = 1,000,000), q_x is the mortality rate, and d_x is the number of deaths at age x. Thus d _x = q_x·l_x. The quantity D_x is computed by the formula D_x = l_x(1+i)^-x. It can be used, for example, to compute the cost of term insurance, since C_x/D_x is the premium for one-year term insurance of $1 at age x.

The sums M_x and N_x are obtained by the formula

We note that for some w. we always have q_x = l, so that l_w+1 = 0 (since l_w+1 = l_w-d_w = l_w-l_w = 0), therefore D_w+1 =0, d_w+1 = 0, C_w+1 = 0, and the sums for M_x and N_x are actually finite sums.

The three most useful quantities computed here are (1)P_x = M_x/N_x, which is the annual premium payable for an entire life for $1 of whole life insurance, (2)A_x = M_x/D_x, which is the single premium payable at age x for $1 of whole life insurance, and (2)a_x = N_x/D_x, which is the present value at age x of a whole life annuity of $1, first payment at age x.

Printing of results is under the control of an input variable PRINT. Certain relationships must hold between some independently computed values, and these are used as checks on the compuatation:

M_b0 + N_b0+1 = N_b0+1 = N_b0/(1+i)

P_x = 1/a_x - i/(1+i)

These cannot be expected to come out exactly equal, because of round-off, but they should differ by very little.

Flow diagram:

The Program:

          R
          R SAMPLE CALLING PROGRAM
          R
            READ FORMAT IN,Q(0)...Q(100)
            VECTOR VALUES IN =$12F6.5* $
            DIMENSION Q(120),L(120),SMALLD(12),BIGD(120),C(120),N(120),
          1 M(120),BIGA(120),SMALLA(120,P(120)
            EXECUTE COMFCN.(Q,0,099,.03,L,SMALLD,BIGD,C,N,M,BIGA,SMALLA,
          1 P,1)
            INTEGER PRINT
            END OF PROGRAM

The External Functions:

          R COMMUTATION TABLE FUNCTION
          R IF PRINT = 0,SUPPRESS PRINTING
            EXTERNAL FUNCTION(Q,BZERO,OMEGA,I,L,SMALLD,BIGD,C,N,
          R M,BIGA,SMALLA,P,PRINT)
            ENTRY TO COMFCN.
            INTEGER BZERO,OMEGA,PRINT,X
            L(BZERO) = 1E6
            V = (1.+ I) .P. -BZERO
            THROUGH A,FOR X = BZERO,1,X .G. OMEGA
            SMALLD(X) = Q(X)*L(X)
            BIGD(X) = L(X)*V
            V = V/(1. + I)
            C(X) = SMALLD(X)*V
A           L(X + 1) = L(X)-SMALLD(X)
            N(OMEGA) = BIGD(OMEGA)
            M(OMEGA) = C(OMEGA)
            THROUGH B, FOR X = OMEGA-1,-1, X .L. BZERO
            N(X) = N(X+1) + BIGD(X)
B           M(X) = M(X+1) + C(X)
            WHENEVER .ABS.(M(BZERO)+N(BZERO)/(I+1.)) .G. 1.,
          1 TRANSFER TO MNERR
E           THROUGH G ,FOR X = BZERO,1,X .G. OMEGA
            BIGA(X) = M(X)/BIGD(X)
            SMALLA(X) = N(X)/BIGD(X)
            P(X) = M(X)/N(X)
            WHENEVER .ABS. (P(X)-1./SMALLA(X) + I/(I+1.)) .G.
          R 1E-4,TRANSFER TO PERROR
G            CONTINUE
            WHENEVER PRINT .E. 0, FUNCTION RETURN
          R
          R OUTPUT GENERATOR
          R
            PRINT FORMAT HEAD01,I
            VECTOR VALUES HEAD01 = $1H1,4HI = F5.4//
          1 4H   X,S13,4HQ(X),S18,4HL(X),S15,10HSMALL D(X),
          1 S8,1HX*$
            THROUGH BETA,FOR X = BZERO,1,X .G. OMEGA
BETA        PRINT FORMAT F1,X,Q(X),L(X),SMALLD(X),X
	    VECTOR VALUES F1 = $1H0,I3,3E22.9,I7*$
	    PRINT FORMAT HEAD02
	    VECTOR VALUES HEAD02 = $1H1,4H   X,S11,8HBIG D(X),
          1 S16,4HC(X),S184HM(X),S18,4HN(X),S11,1HX*$
	    THROUGH GAMA,FOR X=BZERO,1,X .G. OMEGA
GAMMA       PRINT FORMAT F2,X,BIGD(X),C(X),M(X),N(X),X
            VECTOR VALUES F2 = $1H0,I4,4E22.9,17*$
            PRINT FORMAT HEAD03
            VECTOR VALUES HEAD03 = $4H1   X,S11,8HBIG A(X),
          1 S13,10HSMALL A(X), S15,4HP(X),S11,1HX*$
            THROUGH DELTA,FOR X = BZERO,1,X .G. OMEGA
DELTA       PRINT FORMAT F3,X,BIGA(X),SMALLA(X),P(X),X
            VECTOR VALUES F3 = $1H0,I3,3E22.9,17*$
            FUNCTION RETURN
PERROR      PRINT FORMAT PERR,P(X),SMALLA(X),I
            VECTOR VALUES PERR = $27H0ERROR ON P CHECK.  P(X) = E18.9,
          1 S10,13HSMALL A(X) = E18.9,S10,4HI = F5.4*$
            TRANSFER TO G
MNERR       PRINT FORMAT MNERR1
            VECTOR VALUES MNERR1 = $19H0ERROR ON M,N CHECK*$
            TRANSFER TO E
            END OF FUNCTION
* DATA
   2258   577   414   338   299   276   261   247   231   212   197   191  
    192   198   207   215   219   225   230   237   243   251   259   268
    277   288   299   311   325   340   356   373   392   412   435   459
    486   515   546   581   618   659   703   751   804   861   923   991
   1064  1145  1232  1327  1430  1543  1665  1798  1943  2100  2271  2457
   2659  2878  3118  3376  3658  3964  4296  4656  5046  5470  5930  6427
   6966  7550  8181  8864  9602 10399 11259 12186 13185 14260 15416 16657
  17988 19413 20937 22563 24300 26144 28099 30173 32364 34666 37100 39621
  44719 54826 72467100000

Problem: Find the first occurrence of an arbitrary word in a given text.

Analysis: Let N be the number of characters in the text and T(1)...T(N) be the text stored one character per word. Let L be the number of letters in the word which is stored one character per word in W(1)...W(L).

            DIMENSION T(720),W(30)
            NORMAL MODE IS INTEGER
            READ FORMAT CNT,N
            READ FORMAT TXT,T(1)...T(N)
ALPHA       READ FORMAT CNT,L
            READ FORMAT TXT,W(1)...W(N)
            THROUGH SCAN, FOR I=1,1, I .G. N-L+1
            THROUGH TST, FOR J=0,1,J .GE. L
TST         WHENEVER T(I+J) .NE. W(J+1),TRANSFER TO SCAN
            PRINT FORMAT OUT,I,W(1)...W(L)
            TRANSFER TO ALPHA
SCAN        CONTINUE
            PRINT FORMAT NOT
            TRANSFER TO ALPHA
            VECTOR VALUES CNT=$I3*$
            VECTOR VALUES TXT=$72C1*$
            VECTOR VALUES OUT=$11H0CHARACTER I3,13H IS START OF 30C1*$
            VECTOR VALUES NOT=$15H0WORD NOT FOUND*$
            END OF PROGRAM

Problem: Evaluate the recursive function,

f(0) = 1

f(n) = f(n-1) * n

Analysis: This is the definition of n! Although it could have been implemented directly using a THROUGH statement, instead the function will be evaluated using its recursive definition to illustrate how recursive functions can be handled.

            EXTERNAL FUNCTION (N)
            NORMAL MODE IS INTEGER
            ENTRY TO FACT.
            WHENEVER N .E. 0, FUNCTION RETURN 1
            SAVE RETURN
            SAVE DATA N
            T1 = FACT.(N-1)
            RESTORE DATA N
            RESTORE RETURN
            FUNCTION RETURN T1*N
            END OF FUNCTION

In order to use this function, the calling program would have to specify a list for use in the SAVE and RESTORE stayements. The following is an example of a program which uses FACT.

            DIMENSION LIST(100)
            NORMAL MODE IS INTEGER
            SET LIST TO LIST
BACK        READ FORMAT IN, NR
            PRINT FORMAT OUT, NR, FACT.(NR)
            TRANSFER TO BACK
            VECTOR VALUES IN = $I2*$
            VECTOR VALUES OUT = $4H0N= I3,14HN FACTORIAL=  I11*$
            END OF PROGRAM

Problem: To find the greatest common divisor of two integers Y and Z.

Analysis: The greatest common divisor is defined recursively by three equations

Where REM.(A,B) is the remainder of A/B. This function expects the arguments to be found on the temporary storage list as the two most recent additions. The use of the list as a parameter list makes the establishment of dummy variables unnecessary. This is less efficient than the usuall way of defining functions, but serves to remove many pitfalls encountered in using dummy variables with recursive functions.

            EXTERNAL FUNCTION
            INTERNAL FUNCTION REM.(A,B) = (A/B)* B
            ENTRY TO GCD.
            NORMAL MODE IS INTEGER
            RESTORE DATA Z,Y
              WHENEVER Y .G. Z
              SAVE RETURN
              SAVE DATA Z,Y
              X = GCD.(0)
              RESTORE RETURN
              FUNCTION RETURN X
              OR WHENEVER REM.(Z,Y) .E. 0
              FUNCTION RETURN Y
            END OF CONDITIONAL
            SAVE RETURN
            SAVE DATA REM.(Z,Y),Y
            RESTORE RETURN
            FUNCTION RETURN X
            END OF FUNCTION

Note: When called upon for a value, a function such as GCD, must have at least one argument (in this example a dummy argument of zero is used) even though the argument is never called upon. This is because GCD. is the name of the function, wgile GCD.(...) is the value of the function.

Note: The SET LIST TO statement need be executed only once, either in the main program or in a subprogram(but before any use of SAVE or RESTORE), since the SAVE and RESTORE statements always refer to the current list.

An example of a program using GCD. is:

            NORMAL MODE IS INTEGER
            SET LIST TO LIST
            DIMENSION LIST(50)
S           READ FORMAT IN,M,N
            SAVE DATA M,N
            PRINT FORMAT OUT,M,N,GCD.(0)
            TRANSFER TO S
            VECTOR VALUES IN = $2I6*$
            VECTOR VALUES OUT = $1H0,3HN= ,I7,S10,5HGCD = I7
          1 *$
            END OF PROGRAM

Problem: To evaluate Tschebychev polynomials.

Analysis: The Tschebychev polynomial T(N,X) is defined recursively as follows:

It is important to understand that when an expression is written as an argument of a function its value is computed and stored in a temporary location. It is this location (or address) which is actually used as the argument of the function. The implication of this use of a temporary location is that often expressions cannot be used as arguments of recursive functions.

            EXTERNAL FUNCTION (N,X)
            ENTRY TO TSCHEB.
            INTEGER N,Z
            WHENEVER N .E. 0, FUNCTION RETURN 1.
            WHENEVER N .E. 1, FUNCTION RETURN X
            SAVE RETURN
            SAVE DATA N-2
            Z = N-1
            Y = 2.*X*TSCHEB.(Z,X)
            RESTORE DATA Z
            SAVE DATA Y
            M=TSCHEB.(Z,X)
            RESTORE DATA Y
            RESTORE RETURN
            FUNCTION RETURN Y-M
            END OF FUNCTION

A program which uses TSCHEB. is:

            SET LIST TO LIST
            DIMENSION LIST(50)
BEGIN       READ FORMAT INPUT,N,X
            PRINT FORMAT OUTPUT,N,X,TSCHEB.(N,X)
            TRANSFER TO BEGIN
            VECTOR VALUES INPUT = $I6,F10.2*$
            VECTOR VALUES OUTPUT = $1H0,4HN=  ,I6,4H X= F10.23,
          1 11H0FUNCTION= F15.6*$
            END OF PROGRAM