1SECTION : 1.1.1              (DECEMBER 1979)                     PAGE 1
 
 
 
 AUTHOR:     P.A.BEENTJES.
 
 
 INSTITUTE:  MATHEMATICAL CENTRE.
 
 
 RECEIVED:   730715.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS FIVE PROCEDURES.
     INIVEC  INITIALIZES  A  ( PART  OF  A )  VECTOR  WITH  A  CONSTANT.
     INIMAT  INITIALIZES  A  ( PART  OF  A )  MATRIX  WITH  A  CONSTANT.
     INIMATD INITIALIZES ELEMENTS A[I, I+SHIFT], I= LR(1)UR OF A MATRIX.
     INISYMD INITIALIZES A (PART OF A) CODIAGONAL OF A SYMMETRIC MATRIX,
     WHOSE UPPERTRIANGLE  IS  STORED  COLUMNWISE  IN  A  ONE-DIMENSIONAL
     ARRAY.
     INISYMROW INITIALIZES A (PART OF A) ROW OF A SYMMETRIC MATRIX,WHOSE
     UPPERTRIANGLE  IS STORED  COLUMNWISE  IN A  ONE-DIMENSIONAL  ARRAY.
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     INITIALIZATION.
 
 
 SUBSECTION: INIVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" INIVEC(L, U, A, X); "VALUE" L,U,X;
     "INTEGER" L,U; "REAL" X; "ARRAY" A;
     "CODE" 31010;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER  AND  UPPER  INDEX  OF  THE  VECTOR  A, RESPECTIVELY;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], THE ARRAY TO BE INITIALIZED;
     X:      <ARITHMETIC EXPRESSION>;
             INITIALIZATION CONSTANT.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.1              (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: INIMAT.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" INIMAT(LR, UR, LC, UC, A, X); "VALUE" LR,UR,LC,UC,X;
     "INTEGER" LR,UR,LC,UC; "REAL" X; "ARRAY" A;
     "CODE" 31011;
 
     FORMAL PARAMETERS:
     LR,UR,LC,UC: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER ROW-INDEX, AND LOWER AND UPPER COLUMN-INDEX
             OF THE MATRIX A, RESPECTIVELY;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[LR : UR, LC : UC], THE ARRAY TO BE INITIALIZED;
     X:      <ARITHMETIC EXPRESSION>;
             INITIALIZATION CONSTANT.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: INIMATD.
 
 
 CALLING SEQUENCE:
     HEADING:
     "PROCEDURE" INIMATD(LR, UR, SHIFT, A, X); "VALUE" LR,UR,SHIFT,X;
     "INTEGER" LR,UR,SHIFT; "REAL" X; "ARRAY" A;
     "CODE" 31012;
 
     FORMAL PARAMETERS:
     LR,UR:  <ARITHMETIC EXPRESSION>;
             LOWER   AND   UPPER  ROW-INDEX  OF  THE  CODIAGONAL  TO  BE
             INITIALIZED;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             DISTANCE BETWEEN DIAGONAL AND CODIAGONAL;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[LR : UR, LR + SHIFT : UR + SHIFT],  THE  ARRAY TO
             BE INITIALIZED;
     X:      <ARITHMETIC EXPRESSION>;
             INITIALIZATION CONSTANT.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.1              (DECEMBER 1979)                     PAGE 3
 
 
 
 SUBSECTION: INISYMD.
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" INISYMD(LR, UR, SHIFT, A, X); "VALUE" LR,UR,SHIFT,X;
     "INTEGER" LR,UR,SHIFT; "REAL" X; "ARRAY" A;
 
     FORMAL PARAMETERS:
     LR,UR:  <ARITHMETIC EXPRESSION>;
             LOWER  AND UPPER ROW-INDEX OF A CODIAGONAL ( OF A SYMMETRIC
             MATRIX OF ORDER N ) TO BE INITIALIZED;
             LR AND UR SHOULD SATISFY : LR >= 1, UR <= N;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             DISTANCE BETWEEN DIAGONAL AND CODIAGONAL, (-N < SHIFT < N);
     A:      <ARRAY IDENTIFIER>;
             A ONE-DIMENSIONAL ARRAY A[1 : N * (N+1)//2]  CONTAINING THE
             COLUMNWISE  STORED  UPPERTRIANGLE  OF  A  SYMMETRIC MATRIX,
             SUCH  THAT  THE (I,J) - TH  ELEMENT  OF  THE  MATRIX  IS
             A[ (J-1) * J//2 + I ]; J = 1,...,N; I = MAX(1,J-N),...,J;
     X:      <ARITHMETIC EXPRESSION>;
             INITIALIZATION CONSTANT.
 
 LANGUAGE:   ALGOL 60.
 
 
 SUBSECTION: INISYMROW.
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" INISYMROW(L, U, I, A, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER INDEX OF ROW-ELEMENT TO BE INITIALIZED;
     I:      <ARITHMETIC EXPRESSION>;
             ROW INDEX;
     A:      <ARRAY IDENTIFIER>;
             A ONE-DIMENSIONAL ARRAY A[1 : N * (N+1)//2];
             ARRAY A SHOULD CONTAIN A COLUMNWISE STORED UPPERTRIANGLE OF
             A SYMMETRIC MATRIX OF ORDER N,
             SUCH  THAT  THE (I,J) - TH  ELEMENT  OF  THE  MATRIX  IS
             A[ (J - 1) * J//2 + I ]; J = 1, ... ,N; I = 1, ... ,J.
             FOR FIXED ORDER N, THE PARAMETERS L, U AND I SHOULD
             SATISFY THE CONDITIONS :  1 <=L<= N, 1 <=U<= N, 1 <=I<= N ;
     X:      <ARITHMETIC EXPRESSION>;
             INITIALIZATION CONSTANT.
 
 
 LANGUAGE:   ALGOL 60.
 
 
1SECTION : 1.1.1              (DECEMBER 1979)                     PAGE 4
 
 
 
 SOURCE TEXT(S):
 
 THE PROCEDURES INIVEC,  INIMAT AND INIMATD ARE WRITTEN IN  COMPASS,  AN
 EQUIVALENT ALGOL 60 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
 
 
 
 "CODE" 31010;
     "PROCEDURE" INIVEC(L, U, A, X); "VALUE" L,U,X;
     "INTEGER" L,U; "REAL" X; "ARRAY" A;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= X;
         "EOP"
 
 "CODE" 31011;
     "PROCEDURE" INIMAT(LR, UR, LC, UC, A, X); "VALUE" LR,UR,LC,UC,X;
     "INTEGER" LR,UR,LC,UC; "REAL" X; "ARRAY" A;
     "BEGIN" "INTEGER" J;
 
         "FOR" LR:= LR "STEP" 1 "UNTIL" UR "DO"
         "FOR" J:= LC "STEP" 1 "UNTIL" UC "DO" A[LR, J]:= X
     "END" INIMAT;
         "EOP"
 
 "CODE" 31012;
     "PROCEDURE" INIMATD(LR, UR, SHIFT, A, X); "VALUE" LR,UR,SHIFT,X;
     "INTEGER" LR,UR,SHIFT; "REAL" X; "ARRAY" A;
     "FOR" LR:= LR "STEP" 1 "UNTIL" UR "DO" A[LR, LR + SHIFT]:= X;
         "EOP"
 
 "CODE" 31013;
     "PROCEDURE" INISYMD(LR, UR, SHIFT, A, X); "VALUE" LR,UR,SHIFT,X;
     "INTEGER" LR,UR,SHIFT; "REAL" X; "ARRAY" A;
     "BEGIN" SHIFT:= ABS(SHIFT); UR:= UR + SHIFT + 1; SHIFT:=LR + SHIFT;
         LR := (SHIFT - 3) * SHIFT // 2 + LR;
         "FOR" LR := SHIFT + LR "WHILE" SHIFT < UR "DO"
         "BEGIN" A[LR]:= X; SHIFT:= SHIFT + 1 "END"
     "END" INISYMD;
         "EOP"
 
 "CODE" 31014;
     "PROCEDURE" INISYMROW(L, U, I, A, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A;
     "BEGIN" "INTEGER" K;
         "IF" L <= I "THEN"
         "BEGIN" K:= (I - 1) * I//2; L := K + L;
             K := ("IF" U < I "THEN" U "ELSE" I) + K;
             "FOR" L:= L "STEP" 1 "UNTIL" K "DO" A[L]:= X;
             L := I + 1
         "END";
         "IF" U>I "THEN""FOR" K:=(L-1)*L//2+I, K+L-1 "WHILE" L<= U "DO"
         "BEGIN" A[K]:= X; L:= L + 1 "END"
     "END" INISYMROW;
         "EOP"
1SECTION : 1.1.2              (DECEMBER 1979)                     PAGE 1
 
 
 
 AUTHOR:     P.A.BEENTJES.
 
 
 INSTITUTE:  MATHEMATICAL CENTRE.
 
 
 RECEIVED:   730715.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS SIX PROCEDURES.
     DUPVEC COPIES THE VECTOR GIVEN IN ARRAY B[L+SHIFT : U+SHIFT] TO THE
     VECTOR GIVEN IN ARRAY A[L:U].
     DUPVECROW COPIES THE ROW VECTOR GIVEN IN ARRAY  B[I:I, L:U]  TO THE
     VECTOR GIVEN IN ARRAY A[L:U].
     DUPROWVEC COPIES THE VECTOR GIVEN IN ARRAY B[L:U] TO THE ROW VECTOR
     GIVEN IN ARRAY A[I:I, L:U].
     DUPVECCOL  COPIES THE COLUMN VECTOR GIVEN IN ARRAY  B[L:U, J:J]  TO
     THE VECTOR GIVEN IN ARRAY A[L:U].
     DUPCOLVEC  COPIES THE VECTOR GIVEN IN ARRAY  B[L:U]  TO THE  COLUMN
     VECTOR GIVEN IN ARRAY A[L:U, J:J].
     DUPMAT  COPIES THE MATRIX GIVEN IN ARRAY  B[L:U, I:J] TO THE MATRIX
     GIVEN IN ARRAY A[L:U, I:J].
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     DUPLICATION.
 
 
 SUBSECTION: DUPVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" DUPVEC(L, U, SHIFT, A, B); "VALUE" L,U,SHIFT;
     "INTEGER" L,U,SHIFT; "ARRAY" A,B;
     "CODE" 31030;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER VECTOR-INDEX, RESPECTIVELY;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[L + SHIFT : U + SHIFT],   B  IS  COPIED
             INTO A.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.2              (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: DUPVECROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" DUPVECROW(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "CODE" 31031;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER   AND   UPPER  VECTOR ( COLUMN )-INDEX, RESPECTIVELY;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[I : I, L : U], B IS COPIED INTO A.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: DUPROWVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" DUPROWVEC(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "CODE" 31032;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER   AND   UPPER  VECTOR ( COLUMN )-INDEX, RESPECTIVELY;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR A;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[L : U], B IS COPIED INTO A.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.2              (DECEMBER 1979)                     PAGE 3
 
 
 
 SUBSECTION: DUPVECCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" DUPVECCOL(L, U, J, A, B); "VALUE" L,U,J;
     "INTEGER" L,U,J; "ARRAY" A,B;
     "CODE" 31033;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER   AND   UPPER   VECTOR ( ROW )-INDEX,   RESPECTIVELY;
     J:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[L : U, I : I], B IS COPIED INTO A.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: DUPCOLVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" DUPCOLVEC(L, U, J, A, B); "VALUE" L,U,J;
     "INTEGER" L,U,J; "ARRAY" A,B;
     "CODE" 31034;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER   AND   UPPER   VECTOR ( ROW )-INDEX,   RESPECTIVELY;
     J:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR A;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[L : U], B IS COPIED INTO A.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.2              (DECEMBER 1979)                     PAGE 4
 
 
 
 SUBSECTION: DUPMAT.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" DUPMAT(L, U, I, J, A, B); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A,B;
     "CODE" 31035;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER ROW-INDEX, RESPECTIVELY;
     I,J:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER COLUMN-INDEX, RESPECTIVELY;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : J], B[L : U, I : J],  B IS COPIED INTO
             A.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.2              (DECEMBER 1979)                     PAGE 5
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES ARE WRITTEN IN COMPASS, AN EQUIVALENT ALGOL 60
 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
 
 
 
 "CODE" 31030;
     "PROCEDURE" DUPVEC(L, U, SHIFT, A, B); "VALUE" L,U,SHIFT;
     "INTEGER" L,U,SHIFT; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= B[L+SHIFT];
         "EOP"
 
 "CODE" 31031;
     "PROCEDURE" DUPVECROW(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= B[I,L];
         "EOP"
 
 "CODE" 31032;
     "PROCEDURE" DUPROWVEC(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[I,L]:= B[L];
         "EOP"
 
 "CODE" 31033;
     "PROCEDURE" DUPVECCOL(L, U, J, A, B); "VALUE" L,U,J;
     "INTEGER" L,U,J; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= B[L,J];
         "EOP"
 
 "CODE" 31034;
     "PROCEDURE" DUPCOLVEC(L, U, J, A, B); "VALUE" L,U,J;
     "INTEGER" L,U,J; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L,J]:= B[L];
         "EOP"
 
 "CODE" 31035;
     "PROCEDURE" DUPMAT(L, U, I, J, A, B); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A,B;
     "BEGIN" "INTEGER" K;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "FOR" K:= I "STEP" 1 "UNTIL" J "DO" A[L,K]:= B[L,K]
     "END" DUPMAT;
         "EOP"
1SECTION : 1.1.3              (DECEMBER 1979)                     PAGE 1
 
 
 
 AUTHORS:    P.A.BEENTJES, C.G. VAN DER LAAN.
 
 
 INSTITUTE:  MATHEMATICAL CENTRE.
 
 
 RECEIVED:   730715.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS FIVE PROCEDURES.
     MULVEC STORES X TIMES THE VECTOR GIVEN IN ARRAY  B[L+SHIFT:U+SHIFT]
     INTO THE VECTOR GIVEN IN ARRAY A[L:U].
     MULROW STORES X TIMES THE ROW VECTOR GIVEN IN ARRAY B[J:J,L:U] INTO
     THE ROW VECTOR GIVEN IN ARRAY A[I:I,L:U].
     MULCOL STORES X TIMES THE COLUMN VECTOR  GIVEN IN ARRAY  B[L:U,J:J]
     INTO THE COLUMN VECTOR GIVEN IN ARRAY A[L:U,I:I].
     COLCST MULTIPLIES THE COLUMN VECTOR GIVEN IN ARRAY A[L:U,J:J] BY X.
     ROWCST MULTIPLIES THE ROW VECTOR GIVEN IN ARRAY A[I:I,L:U] BY X.
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     MULTIPLICATIONS.
 
 
 SUBSECTION: MULVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" MULVEC(L, U, SHIFT, A, B, X); "VALUE" L,U,SHIFT,X;
     "INTEGER" L,U,SHIFT; "REAL" X; "ARRAY" A,B;
     "CODE" 31020;
 
     FORMAL PARAMETERS:
     L,U:    <ARITMETIC EXPRESSION>;
             LOWER AND UPPER VECTOR-INDEX, RESPECTIVELY;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             SUBSCRIPT-SHIFTING PARAMETER;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[L + SHIFT : U + SHIFT],  THE PRODUCT OF
             THE CONTENTS OF B ARE STORED IN A.
     X:      <ARITHMETIC EXPRESSION>;
             MULTIPLICATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.3              (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: MULROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" MULROW(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 31021;
 
     FORMAL PARAMETERS:
     L,U:    <ARITMETIC EXPRESSION>;
             LOWER AND UPPER COLUMN-INDEX, RESPECTIVELY;
     I,J:    <ARITHMETIC EXPRESSION>;
             ROW-INDICES OF THE ROW VECTORS A AND B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[J : J, L : U], THE CONTENTS OF B
             MULTIPLIED BY X ARE STORED INTO A.
     X:      <ARITHMETIC EXPRESSION>;
             MULTIPLICATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: MULCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" MULCOL(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 31022;
 
     FORMAL PARAMETERS:
     L,U:    <ARITMETIC EXPRESSION>;
             LOWER AND UPPER ROW-INDEX, RESPECTIVELY;
     I,J:    <ARITHMETIC EXPRESSION>;
             COLUMN-INDICES OF THE COLUMN VECTORS A AND B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[L : U, J : J], THE CONTENTS OF B
             MULTIPLIED BY X ARE STORED INTO A;
     X:      <ARITHMETIC EXPRESSION>;
             MULTIPLICATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.3              (DECEMBER 1979)                     PAGE 3
 
 
 
 SUBSECTION: COLCST.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" COLCST(L, U, J, A, X); "VALUE" L,U,J,X;
     "INTEGER" L,U,J; "REAL" X; "ARRAY" A;
     "CODE" 31131;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER ROW-INDEX, RESPECTIVELY;
     J:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, J : J];
     X:      <ARITHMETIC EXPRESSION>;
             MULTIPLICATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ROWCST.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ROWCST(L, U, I, A, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A;
     "CODE" 31132;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER COLUMN-INDEX, RESPECTIVELY;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U];
     X:      <ARITHMETIC EXPRESSION>;
             MULTIPLICATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.3              (DECEMBER 1979)                     PAGE 4
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES ARE WRITTEN IN COMPASS, AN EQUIVALENT ALGOL 60
 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
 
 
 
 "CODE" 31020;
     "PROCEDURE" MULVEC(L, U, SHIFT, A, B, X); "VALUE" L,U,SHIFT,X;
     "INTEGER" L,U,SHIFT; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= B[L+SHIFT]*X;
         "EOP"
 
 "CODE" 31021;
     "PROCEDURE" MULROW(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[I,L]:= B[J,L]*X;
         "EOP"
 
 "CODE" 31022;
     "PROCEDURE" MULCOL(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L,I]:= B[L,J]*X;
         "EOP"
 
 "CODE" 31131;
     "PROCEDURE" COLCST(L, U, J, A, X); "VALUE" L,U,J,X;
     "INTEGER" L,U,J; "REAL" X; "ARRAY" A;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L,J]:= A[L,J] * X;
         "EOP"
 
 "CODE" 31132;
     "PROCEDURE" ROWCST(L, U, I, A, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[I,L]:= A[I,L] * X;
         "EOP"
1SECTION : 1.1.4.1            (DECEMBER 1975)                     PAGE 1
 
 
 
 AUTHORS:        T.J.DEKKER, J.C.P.BUS, J.WOLLESWINKEL.
 
 
 CONTRIBUTORS:   P.A.BEENTJES, J.C.P.BUS.
 
 
 INSTITUTE:      MATHEMATICAL CENTRE.
 
 
 RECEIVED:       741215.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS NINE PROCEDURES.
     VECVEC:= SCALAR PRODUCT OF  THE VECTOR  GIVEN  IN  ARRAY A[L:U] AND
     ARRAY B[SHIFT + L : SHIFT + U].
     MATVEC:= SCALAR PRODUCT OF THE ROW VECTOR GIVEN IN ARRAY A[I:I,L:U]
     AND THE VECTOR GIVEN IN ARRAY B[L:U].
     TAMVEC:= SCALAR  PRODUCT  OF  THE  COLUMN  VECTOR  GIVEN  IN  ARRAY
     A[L:U, I:I] AND THE VECTOR GIVEN IN ARRAY B[L:U].
     MATMAT:= SCALAR PRODUCT OF THE ROW VECTOR GIVEN IN ARRAY A[I:I,L:U]
     AND THE COLUMN VECTOR IN ARRAY B[L:U, J:J].
     TAMMAT:= SCALAR  PRODUCT  OF  THE  COLUMN VECTORS  GIVEN  IN  ARRAY
     A[L:U, I:I] AND ARRAY B[L:U, J:J].
     MATTAM :=  SCALAR  PRODUCT  OF  THE  ROW  VECTORS  GIVEN  IN  ARRAY
     A[I:I,L:U] AND ARRAY B[J:J, L:U].
     SEQVEC :=  SCALAR   PRODUCT   OF   THE   VECTORS   GIVEN  IN  ARRAY
     A[IL : IL + (U+L-1)*(U-L)//2]  AND ARRAY  B[SHIFT + L : SHIFT + U],
     WHERE THE ELEMENTS OF  THE FIRST VECTOR ARE  A[IL+(J+L-1)*(J-L)//2]
     FOR J = L, ..., U.
     SCAPRD1:=  SCALAR   PRODUCT   OF   THE   VECTORS   GIVEN  IN  ARRAY
     A[MIN(LA, LA + (N - 1) * SA) : MAX(LA,LA + (N - 1) * SA)] AND ARRAY
     B[MIN(LB, LB + (N - 1) * SB) : MAX(LB,LB + (N - 1) * SB)] WHERE THE
     ELEMENTS  OF  THE  VECTORS  ARE  A[LA+(J-1)*SA] AND  B[LB+(J-1)*SB]
     FOR J = 1, ..., N.
     SYMMATVEC := THE SCALARPRODUCT OF ( A PART OF ) A VECTOR AND
     ( A PART OF ) A ROW OF A SYMMETRIC MATRIX , WHOSE  UPPERTRIANGLE IS
     GIVEN COLUMNWISE IN AN ONE-DIMENSIONAL ARRAY.
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     SCALAR PRODUCTS.
1SECTION : 1.1.4.1            (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: VECVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" VECVEC(L, U, SHIFT, A, B); "VALUE" L,U,SHIFT;
     "INTEGER" L,U,SHIFT; "ARRAY" A,B;
     "CODE" 34010;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER OF THE VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[L + SHIFT : U + SHIFT].
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: MATVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" MATVEC(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "CODE" 34011;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR A;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[L : U].
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.4.1            (DECEMBER 1979)                     PAGE 3
 
 
 
 SUBSECTION: TAMVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" TAMVEC(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "CODE" 34012;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR A;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[L : U].
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: MATMAT.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" MATMAT(L, U, I, J, A, B); "VALUE" L,U,I,J;
     "CODE" 34013;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             ROW-INDEX  OF  THE ROW VECTOR  A  AND  COLUMN-INDEX  OF THE
             COLUMN VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[L : U, J : J].
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.4.1            (DECEMBER 1979)                     PAGE 4
 
 
 
 SUBSECTION: TAMMAT.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" TAMMAT(L, U, I, J, A, B); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A,B;
     "CODE" 34014;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             COLUMN-INDICES OF THE COLUMN VECTORS A AND B, RESPECTIVELY;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[L : U, J : J].
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: MATTAM.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" MATTAM(L, U, I, J, A, B); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A,B;
     "CODE" 34015;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             ROW-INDICES  OF  THE  ROW VECTORS  A  AND  B, RESPECTIVELY;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[J : J, L : U].
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.4.1            (DECEMBER 1979)                     PAGE 5
 
 
 
 SUBSECTION: SEQVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" SEQVEC(L, U, IL, SHIFT, A, B);
     "CODE" 34016;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     IL:     <ARITHMETIC EXPRESSION>;
             LOWER BOUND OF THE VECTOR A;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER OF THE VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q], B[L + SHIFT, U + SHIFT];
             THE VALUES OF P AND  Q  SHOULD  SATISFY  P <= IL  AND  Q >=
             IL+(U+L-1)*(U-L)//2).
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: SCAPRD1.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "REAL" "PROCEDURE" SCAPRD1(LA, SA, LB, SB, N, A, B);
     "VALUE" LA,SA,LB,SB,N; "INTEGER" LA,SA,LB,SB,N; "ARRAY" A,B;
     "CODE" 34017;
 
     FORMAL PARAMETERS:
     N:      <ARITHMETIC EXPRESSION>;
             UPPER BOUND OF THE RUNNING SUBSCRIPT;
     LA,LB:  <ARITHMETIC EXPRESSION>;
             LOWER   BOUNDS   OF   THE VECTORS  A  AND  B, RESPECTIVELY;
     SA,SB:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING   PARAMETERS   OF   THE  VECTORS  A  AND  B,
             RESPECTIVELY;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q], B[R : S];
             THE SUBSCRIPTS ABOVE AND THE VALUES OF LA( +(J-1)*SA )  AND
             LB( +(J-1)*SB ),J = 1(1)N SHOULD NOT CONTRADICT EACH OTHER.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.4.1            (MARCH 1977)                        PAGE 6
 
 
 
 SUBSECTION: SYMMATVEC.
 
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE READS:
     "REAL" PROCEDURE" SYMMATVEC(L, U, I, A, B); "VALUE" L,U,I;
     "INTEGER" L,U,I; "ARRAY" A,B;
     "CODE" 34018;
 
 
     SYMMATVEC:= THE VALUE OF THE SCALAR PRODUCT OF THE VECTORS GIVEN
                 IN  ARRAY A[P:Q] AND  ARRAY B[L:U] , WHERE THE ELEMENTS
                 OF THE FIRST VECTOR ARE: IF L<I THEN A[(I-1)*I//2 + J],
                 J=L,..., MIN(U, I-1) AND A[(J-1)*J//2 + I], J=I,..., U,
                 RESPECTIVELY , OTHERWISE A[(J-1)*J//2 + I], J=L,..., U.
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE VECTOR B, RESPECTIVELY; L >=1;
     I:      <ARITHMETIC EXPRESSION>;
             ROW INDEX OF THE MATRIX A; I >= 1;
     A:      <ARRAY IDENTIFIER>;
             A  ONE-DIMENSIONAL  ARRAY  A[P : Q]  WITH:  IF  I > L  THEN
             P=(I-1)*I//2 + L ELSE  P=(L-1)*L//2 + I AND IF  I > U  THEN
             Q=(I-1)*I//2 + U ELSE  Q=(U-1)*U//2 + I;
     B:      <ARRAY IDENTIFIER>;
             A ONE-DIMENSIONAL ARRAY B[L:U];
 
 
 PROCEDURES USED:
 
            VECVEC = CP34010,
            SEQVEC = CP34016.
 
 
 LANGUAGE:   ALGOL 60.
 
 
 METHOD AND PERFORMANCE:
 
            SEE REFERENCE [2].
 
 REFERENCES :
 
        [1]  T.J.DEKKER.
             ALGOL 60 PROCEDURES IN NUMERICAL ALGEBRA,PART 1,
             MATHEMATICAL CENTRE TRACT 22,AMSTERDAM (1970)
        [2]  J.C.P.BUS.
             MINIMALISERING VAN FUNCTIES VAN MEERDERE VARIABELEN,
             MATHEMATICAL CENTRE, NR 29/72,AMSTERDAM (1972)
1SECTION : 1.1.4.1            (DECEMBER 1979)                     PAGE 7
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES,  EXCEPT FOR SYMMATVEC ARE WRITTEN IN COMPASS,
 AN EQUIVALENT ALGOL 60 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
 
0"CODE" 34010;
    "REAL" "PROCEDURE" VECVEC(L, U, SHIFT, A, B); "VALUE" L,U,SHIFT;
    "INTEGER" L,U,SHIFT; "ARRAY" A,B;
    "BEGIN" "INTEGER" K; "REAL" S;
        S:= 0;
        "FOR" K:=L "STEP" 1 "UNTIL" U "DO" S:= A[K] * B[SHIFT + K] + S;
        VECVEC:= S
    "END" VECVEC;
        "EOP"
0"CODE" 34011;
    "REAL" "PROCEDURE" MATVEC(L, U, I, A, B); "VALUE" L,U,I;
    "INTEGER" L,U,I; "ARRAY" A,B;
    "BEGIN" "INTEGER" K; "REAL" S;
        S:= 0;
        "FOR" K:=L "STEP" 1 "UNTIL" U "DO" S:= A[I,K] * B[K] + S;
        MATVEC:= S
    "END" MATVEC;
        "EOP"
0"CODE" 34012;
    "REAL" "PROCEDURE" TAMVEC(L, U, I, A, B); "VALUE" L,U,I;
    "INTEGER" L,U,I; "ARRAY" A,B;
    "BEGIN" "INTEGER" K; "REAL" S;
        S:= 0;
        "FOR" K:=L "STEP" 1 "UNTIL" U "DO" S:= A[K,I] * B[K] + S;
        TAMVEC:= S
    "END" TAMVEC;
        "EOP"
0"CODE" 34013;
    "REAL" "PROCEDURE" MATMAT(L, U, I, J, A, B); "VALUE" L,U,I,J;
    "INTEGER" L,U,I,J; "ARRAY" A,B;
    "BEGIN" "INTEGER" K; "REAL" S;
        S:= 0;
        "FOR" K:=L "STEP" 1 "UNTIL" U "DO" S:= A[I,K] * B[K,J] + S;
        MATMAT:= S
    "END" MATMAT;
        "EOP"
1SECTION : 1.1.4.1            (DECEMBER 1975)                     PAGE 8
 
 
 
0"CODE" 34014;
    "REAL" "PROCEDURE" TAMMAT(L, U, I, J, A, B); "VALUE" L,U,I,J;
    "INTEGER" L,U,I,J; "ARRAY" A,B;
    "BEGIN" "INTEGER" K; "REAL" S;
        S:= 0;
        "FOR" K:=L "STEP" 1 "UNTIL" U "DO" S:= A[K,I] * B[K,J] + S;
        TAMMAT:= S
    "END" TAMMAT;
        "EOP"
0"CODE" 34015;
    "REAL" "PROCEDURE" MATTAM(L, U, I, J, A, B); "VALUE" L,U,I,J;
    "INTEGER" L,U,I,J; "ARRAY" A,B;
    "BEGIN" "INTEGER" K; "REAL" S;
        S:= 0;
        "FOR" K:=L "STEP" 1 "UNTIL" U "DO" S:= A[I,K] * B[J,K] + S;
        MATTAM:= S
    "END" MATTAM;
        "EOP"
0"CODE" 34016;
    "REAL" "PROCEDURE" SEQVEC(L, U, IL, SHIFT, A, B);
    "VALUE" L,U,IL,SHIFT; "INTEGER" L,U,IL,SHIFT; "ARRAY" A,B;
    "BEGIN" "REAL" S;
        S:= 0;
        "FOR" L:=L "STEP" 1 "UNTIL" U "DO"
        "BEGIN" S:= A[IL] * B[L + SHIFT] + S; IL:= IL + L "END";
        SEQVEC:= S
    "END" SEQVEC;
        "EOP"
0"CODE" 34017;
    "REAL" "PROCEDURE" SCAPRD1(LA, SA, LB, SB, N, A, B);
    "VALUE" LA,SA,LB,SB,N; "INTEGER" LA,SA,LB,SB,N; "ARRAY" A,B;
    "BEGIN" "REAL" S;"INTEGER" K;
        S:= 0;
        "FOR" K:= 1 "STEP" 1 "UNTIL" N "DO"
        "BEGIN" S:=A[LA] * B[LB] + S; LA:= LA + SA; LB:= LB + SB "END";
        SCAPRD1:= S
    "END" SCAPRD1;
        "EOP"
0"CODE" 34018;
    "REAL" "PROCEDURE" SYMMATVEC(L, U, I, A, B); "VALUE" L,U,I;
    "INTEGER" L,U,I; "ARRAY" A,B;
    "BEGIN" "INTEGER" K, M;
        "REAL" "PROCEDURE" VECVEC(L, U, SHIFT, A, B); "CODE" 34010;
        "REAL" "PROCEDURE" SEQVEC(L, U, IL, SHIFT, A, B); "CODE" 34016;
        M:= "IF" L > I "THEN" L "ELSE" I; K:= M * (M - 1) // 2;
        SYMMATVEC:= VECVEC(L, "IF" I <= U "THEN" I-1 "ELSE" U, K, B, A)
                    + SEQVEC(M, U, K + I, 0, A, B)
    "END" SYMMATVEC;
        "EOP"
1SECTION : 1.1.5              (APRIL 1974)                        PAGE 1
 
 
 
 AUTHORS:        T.J.DEKKER, C.G. VAN DER LAAN.
 
 
 CONTRIBUTOR:    P.A.BEENTJES.
 
 
 INSTITUTE:      MATHEMATICAL CENTRE.
 
 
 RECEIVED:       730715.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS TEN PROCEDURES.
     ELMVEC ADDS X TIMES THE VECTOR GIVEN IN ARRAY  B[SHIFT+L : SHIFT+U]
     TO THE VECTOR GIVEN IN ARRAY A[L:U].
     ELMCOL ADDS X TIMES THE COLUMN VECTOR GIVEN IN ARRAY B[L:U, J:J] TO
     THE COLUMN VECTOR GIVEN IN ARRAY A[L:U, I:I].
     ELMROW ADDS  X TIMES  THE ROW VECTOR GIVEN IN ARRAY  B[J:J, L:U] TO
     THE ROW VECTOR GIVEN IN ARRAY A[I:I, L:U].
     ELMVECCOL ADDS X TIMES THE COLUMN VECTOR GIVEN IN ARRAY B[L:U, I:I]
     TO THE VECTOR GIVEN IN ARRAY A[L:U].
     ELMCOLVEC  ADDS  X  TIMES  THE VECTOR  GIVEN IN ARRAY B[L:U] TO THE
     COLUMN VECTOR GIVEN IN ARRAY A[L:U, I:I].
     ELMVECROW ADDS X TIMES THE ROW VECTOR GIVEN IN ARRAY B[I:I, L:U] TO
     THE VECTOR GIVEN IN ARRAY A[L:U].
     ELMROWVEC  ADDS  X  TIMES  THE VECTOR  GIVEN IN ARRAY B[L:U] TO THE
     ROW VECTOR GIVEN IN ARRAY A[I:I, L:U].
     ELMCOLROW ADDS X TIMES THE ROW VECTOR GIVEN IN ARRAY B[J:J, L:U] TO
     THE COLUMN VECTOR GIVEN IN ARRAY A[L:U, I:I].
     ELMROWCOL ADDS X TIMES THE COLUMN VECTOR GIVEN IN ARRAY B[L:U, J:J]
     TO THE ROW VECTOR GIVEN IN ARRAY A[I:I, L:U].
     MAXELMROW ADDS X TIMES THE ROW VECTOR GIVEN IN ARRAY B[J:J, L:U] TO
     THE ROW VECTOR GIVEN IN ARRAY A[I:I, L:U].
     MOREOVER, MAXELMROW:= THE  VALUE  OF  THE  SECOND  SUBSCRIPT  OF AN
     ELEMENT  OF  THE  NEW  ROW VECTOR  IN  ARRAY A  WHICH IS OF MAXIMUM
     ABSOLUTE VALUE.
     IF, HOWEVER, L > U, THEN MAXELMROW:= L.
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     ELIMINATION.
 
 
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: ELMVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMVEC(L, U, SHIFT, A, B, X); "VALUE" L,U,SHIFT,X;
     "INTEGER" L,U,SHIFT; "REAL" X; "ARRAY" A,B;
     "CODE" 34020;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER OF THE VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[L + SHIFT : U + SHIFT];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ELMCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMCOL(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 34023;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR A;
     J:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[L : U, J : J];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 3
 
 
 
 SUBSECTION: ELMROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMROW(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 34024;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR A;
     J:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[J : J, L : U];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ELMVECCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMVECCOL(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "CODE" 34021;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[L : U, I : I];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 4
 
 
 
 SUBSECTION ELMCOLVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMCOLVEC(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "CODE" 34022;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR A;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[L : U];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ELMVECROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMVECROW(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "CODE" 34026;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U], B[I : I, L : U];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 5
 
 
 
 SUBSECTION: ELMROWVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMROWVEC(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "CODE" 34027;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR A;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[L : U];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ELMCOLROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMCOLROW(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 34029;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR A;
     J:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, I : I], B[J : J, L : U],  WHEN  A = B THEN
             CORRECT  ELIMINATION  IS GUARANTEED  ONLY WHEN  THE ROW AND
             COLUMN ARE DISJUNCT;
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 6
 
 
 
 SUBSECTION: ELMROWCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ELMROWCOL(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 34028;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR A;
     J:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[L : U, J : J],  WHEN  A = B THEN
             CORRECT  ELIMINATION  IS GUARANTEED  ONLY WHEN  THE ROW AND
             COLUMN ARE DISJUNCT;
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 7
 
 
 
 SUBSECTION: MAXELMROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "INTEGER" "PROCEDURE" MAXELMROW(L, U, I, J, A, B, X);
     "VALUE" L,U,I,J,X; "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "CODE" 34025;
 
     MAXELMROW DELIVERS THE INDEX  OF THE MAXIMAL ELEMENT AFTER ELIMINA-
             TION STEP IN ARRAY A.
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR A;
     J:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR B;
     A,B:    <ARRAY IDENTIFIER>;
             "ARRAY" A[I : I, L : U], B[I : I, L : U];
     X:      <ARITHMETIC EXPRESSION>;
             ELIMINATION FACTOR.
 
 
 LANGUAGE: COMPASS.
 
 
 REFERENCES:
 
     [1].T.J.DEKKER.
         ALGOL 60 PROCEDURES IN NUMERICAL ALGEBRA, PART 1,
         MATHEMATICAL CENTRE TRACT 22, AMSTERDAM (1970).
1SECTION : 1.1.5              (DECEMBER 1979)                     PAGE 8
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES ARE WRITTEN IN COMPASS, AN EQUIVALENT ALGOL 60
 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
     ELMVEC
     ELMROW
     ELMVECCOL
     ELMCOLVEC
     MAXELMROW
 
 "CODE" 34020;
     "PROCEDURE" ELMVEC(L, U, SHIFT, A, B, X); "VALUE" L,U,SHIFT,X;
     "INTEGER" L,U,SHIFT; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= A[L] + B[L + SHIFT] * X;
         "EOP"
 
 "CODE" 34023;
     "PROCEDURE" ELMCOL(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L,I]:= A[L,I] + B[L,J] * X;
         "EOP"
 
 "CODE" 34024;
     "PROCEDURE" ELMROW(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[I,L]:= A[I,L] + B[J,L] * X;
         "EOP"
 
 "CODE" 34021;
     "PROCEDURE" ELMVECCOL(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= A[L] + B[L,I] * X;
         "EOP"
 
 "CODE" 34022;
     "PROCEDURE" ELMCOLVEC(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L,I]:= A[L,I] + B[L] * X;
         "EOP"
 
 "CODE" 34026;
     "PROCEDURE" ELMVECROW(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L]:= A[L] + B[I,L] * X;
         "EOP"
 
1SECTION : 1.1.5              (APRIL 1974)                        PAGE 9
 
 
 
 "CODE" 34027;
     "PROCEDURE" ELMROWVEC(L, U, I, A, B, X); "VALUE" L,U,I,X;
     "INTEGER" L,U,I; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[I,L]:= A[I,L] + B[L] * X;
         "EOP"
 
 "CODE" 34029;
     "PROCEDURE" ELMCOLROW(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[L,I]:= A[L,I] + B[J,L] * X;
         "EOP"
 
 "CODE" 34028;
     "PROCEDURE" ELMROWCOL(L, U, I, J, A, B, X); "VALUE" L,U,I,J,X;
     "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "FOR" L:= L "STEP" 1 "UNTIL" U "DO" A[I,L]:= A[I,L] + B[L,J] * X;
         "EOP"
 
 "CODE" 34025;
     "INTEGER" "PROCEDURE" MAXELMROW(L, U, I, J, A, B, X);
     "VALUE" L,U,I,J,X; "INTEGER" L,U,I,J; "REAL" X; "ARRAY" A,B;
     "BEGIN" "INTEGER" K; "REAL" R, S;
         S:= 0;
         "FOR" K:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[I,K]:= A[I,K] + B[J,K] * X;"IF" ABS(R) > S "THEN"
             "BEGIN" S:= ABS(R); L:= K "END"
         "END";
         MAXELMROW:= L
     "END" MAXELMROW;
         "EOP"
 
 
 
 
1SECTION : 1.1.6              (APRIL 1974)                        PAGE 1
 
 
 
 AUTHOR:         T.J.DEKKER.
 
 
 CONTRIBUTOR:    P.A.BEENTJES.
 
 
 INSTITUTE:      MATHEMATICAL CENTRE.
 
 
 RECEIVED:       730715.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS SIX PROCEDURES.
     ICHVEC  INTERCHANGES  THE ELEMENTS  OF  THE VECTOR  GIVEN IN  ARRAY
     A[L:U] AND ARRAY A[SHIFT + L : SHIFT + U].
     ICHCOL  INTERCHANGES  THE ELEMENTS  OF THE COLUMN VECTORS  GIVEN IN
     ARRAY A[L:U, I:I] AND ARRAY A[L:U, J:J].
     ICHROW INTERCHANGES THE ELEMENTS OF THE ROW VECTORS GIVEN IN  ARRAY
     A[I:I, L:U] AND ARRAY A[J:J, L:U].
     ICHROWCOL  INTERCHANGES  THE ELEMENTS  OF  THE  ROW VECTOR GIVEN IN
     ARRAY A[I:I, L:U] AND THE COLUMN VECTOR GIVEN IN ARRAY A[L:U, J:J].
     ICHSEQVEC INTERCHANGES THE ELEMENTS OF THE VECTORS  GIVEN IN  ARRAY
     A[IL : IL + (U + L - 1)*(U - L)//2] AND ARRAY A[SHIFT+L : SHIFT+U],
     WHERE THE ELEMENTS OF THE FIRST VECTOR  ARE  A[IL+(J+L-1)*(J-L)//2]
     FOR J = L,..., U.
     ICHSEQ   INTERCHANGES   THE   ELEMENTS   OF   THE   VECTORS   GIVEN
     IN   ARRAY    A[IL : IL + (U + L - 1) * (U - L) // 2]   AND   ARRAY
     A[SHIFT + IL : SHIFT + IL + (U + L - 1) * (U - L) // 2]  WHERE  THE
     ELEMENTS OF THE VECTORS ARE A[IL + (J + L - 1) * (J - L) // 2]  AND
     A[SHIFT + IL + (J + L - 1) * (J - L) // 2]   FOR   J = L ,..., U  .
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     INTERCHANGING.
 
 
1SECTION : 1.1.6              (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: ICHVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ICHVEC(L, U, SHIFT, A); "VALUE" L,U,SHIFT;
     "INTEGER" L,U,SHIFT; "ARRAY" A;
     "CODE" 34030;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q]; P AND Q SHOULD SATISFY:  P <= L,  Q >= U,
             P <= L + SHIFT AND Q >= U + SHIFT.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ICHCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ICHCOL(L, U, I, J, A); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A;
     "CODE" 34031;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             COLUMN-INDICES   OF   THE  COLUMN  VECTORS   OF   ARRAY  A;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, P : Q]; P AND Q SHOULD SATISFY:  P  <=  I,
             P <= J, Q >= I AND Q >= J.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.6              (DECEMBER 1979)                     PAGE 3
 
 
 
 SUBSECTION: ICHROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ICHROW(L, U, I, J, A); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A;
     "CODE" 34032;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             ROW-INDICES OF THE ROW VECTORS OF ARRAY A;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q, L : U]; P AND Q SHOULD SATISFY:  P  <=  I,
             P <= J, Q >= I AND Q >= J.
 
 
 LANGUAGE: COMPASS.
 
 
 SUBSECTION: ICHROWCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ICHROWCOL(L, U, I, J, A); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A;
     "CODE" 34033;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I:      <ARITHMETIC EXPRESSION>;
             ROW-INDEX OF THE ROW VECTOR OF ARRAY A;
     J:      <ARITHMETIC EXPRESSION>;
             COLUMN-INDEX OF THE COLUMN VECTOR OF ARRAY A;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q, R : S]; P,  Q,  R  AND  S  SHOULD SATISFY:
             P <= I, P <= L, Q >= I, Q >= U, R <= J, R <= L, S >= J  AND
             S >= U,  FURTHERMORE THE ROW AND COLUMN  TO BE INTERCHANGED
             SHOULD BE DISJUNCT.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.6              (DECEMBER 1979)                     PAGE 4
 
 
 
 SUBSECTION: ICHSEQVEC.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ICHSEQVEC(L, U, IL, SHIFT, A); "VALUE" L,U,IL,SHIFT;
     "INTEGER" L,U,IL,SHIFT; "ARRAY" A;
     "CODE" 34034;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     IL:     <ARITHMETIC EXPRESSION>;
             LOWER BOUND OF THE VECTOR A;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q];
             THE SUBSCRIPTS ABOVE AND THE VALUES OF L(+SHIFT), U(+SHIFT)
             AND IL+(U+L-1)*(U-L)//2 SHOULD NOT CONTRADICT EACH OTHER.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.6              (DECEMBER 1979)                     PAGE 5
 
 
 
 SUBSECTION: ICHSEQ.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ICHSEQ(L, U, IL, SHIFT, A); "VALUE" L,U,IL,SHIFT;
     "INTEGER" L,U,IL,SHIFT; "ARRAY" A;
     "CODE" 34035;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     IL:     <ARITHMETIC EXPRESSION>;
             LOWER BOUND OF THE VECTOR A;
     SHIFT:  <ARITHMETIC EXPRESSION>;
             INDEX-SHIFTING PARAMETER;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q];
             THE SUBSCRIPTS ABOVE AND THE VALUES OF  IL+(J+L-1)*(J-L)//2
             ( +SHIFT ),J = L(1)U, SHOULD  NOT  CONTRADICT  EACH  OTHER.
 
 
 LANGUAGE: COMPASS.
 
 
 REFERENCES:
 
     [1].T.J.DEKKER.
         ALGOL 60 PROCEDURES IN NUMERICAL ALGEBRA, PART 1,
         MATHEMATICAL CENTRE TRACT 22, AMSTERDAM (1970).
1SECTION : 1.1.6              (DECEMBER 1979)                     PAGE 6
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES ARE WRITTEN IN COMPASS, AN EQUIVALENT ALGOL 60
 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
 
 
 
 "CODE" 34030;
     "PROCEDURE" ICHVEC(L, U, SHIFT, A); "VALUE" L,U,SHIFT;
     "INTEGER" L,U,SHIFT; "ARRAY" A;
     "BEGIN" "REAL" R;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[L]; A[L]:= A[L + SHIFT]; A[L + SHIFT]:= R "END"
     "END" ICHVEC;
        "EOP"
 
 "CODE" 34031;
     "PROCEDURE" ICHCOL(L, U, I, J, A); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A;
     "BEGIN" "REAL" R;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[L,I]; A[L,I]:= A[L,J]; A[L,J]:= R "END"
     "END" ICHCOL;
         "EOP"
 
 "CODE" 34032;
     "PROCEDURE" ICHROW(L, U, I, J, A); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A;
     "BEGIN" "REAL" R;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[I,L]; A[I,L]:= A[J,L]; A[J,L]:= R "END"
     "END" ICHROW;
         "EOP"
 
1SECTION : 1.1.6              (APRIL 1974)                        PAGE 7
 
 
 
 "CODE" 34033;
     "PROCEDURE" ICHROWCOL(L, U, I, J, A); "VALUE" L,U,I,J;
     "INTEGER" L,U,I,J; "ARRAY" A;
     "BEGIN" "REAL" R;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[I,L]; A[I,L]:= A[L,J]; A[L,J]:= R "END"
     "END" ICHROWCOL;
         "EOP"
 
 "CODE" 34034;
     "PROCEDURE" ICHSEQVEC(L, U, IL, SHIFT, A); "VALUE" L,U,IL,SHIFT;
     "INTEGER" L,U,IL,SHIFT; "ARRAY" A;
     "BEGIN" "REAL" R;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[IL]; A[IL]:= A[L + SHIFT]; A[L + SHIFT]:= R;
             IL:= IL + L
         "END"
     "END" ICHSEQVEC;
         "EOP"
 
 "CODE" 34035;
     "PROCEDURE" ICHSEQ(L, U, IL, SHIFT, A); "VALUE" L,U,IL,SHIFT;
     "INTEGER" L,U,IL,SHIFT; "ARRAY" A;
     "BEGIN" "REAL" R;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" R:= A[IL]; A[IL]:= A[IL + SHIFT]; A[IL + SHIFT]:= R;
             IL:= IL + L
         "END"
     "END" ICHSEQ;
         "EOP"
1SECTION : 1.1.7              (DECEMBER 1979)                     PAGE 1
 
 
 
 AUTHOR:     P.A.BEENTJES.
 
 
 INSTITUTE:  MATHEMATICAL CENTRE.
 
 
 RECEIVED:   730715.
 
 
 BRIEF DESCRIPTION:
 
     THIS SECTION CONTAINS TWO PROCEDURES.
     ROTCOL REPLACES THE COLUMN VECTOR X GIVEN IN ARRAY  A[L:U, I:I] AND
     THE  COLUMN VECTOR  Y  GIVEN IN ARRAY  A[L:U, J:J]  BY  THE VECTORS
     CX + SY AND CY - SX.
     ROTROW REPLACES THE ROW VECTOR X GIVEN IN ARRAY A[I:I, L:U] AND THE
     ROW VECTOR Y GIVEN IN ARRAY A[J:J, L:U] BY THE VECTORS CX + SY  AND
     CY - SX.
 
 
 KEYWORDS:
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATIONS,
     ROTATION.
 
 
 SUBSECTION: ROTCOL.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ROTCOL(L, U, I, J, A, C, S); "VALUE" L,U,I,J,C,S;
     "INTEGER" L,U,I,J; "REAL" C,S; "ARRAY" A;
     "CODE" 34040;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             COLUMN-INDICES OF THE COLUMN VECTORS OF ARRAY A;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[L : U, P : Q]; P AND Q SHOULD SATISFY:  P  <=  I,
             P <= J, Q >= I AND Q >= J;
     C,S:    <ARITHMETIC EXPRESSION>;
             ROTATION FACTORS.
 
 
 LANGUAGE: COMPASS.
1SECTION : 1.1.7              (DECEMBER 1979)                     PAGE 2
 
 
 
 SUBSECTION: ROTROW.
 
 
 CALLING SEQUENCE:
 
     HEADING:
     "PROCEDURE" ROTROW(L, U, I, J, A, C, S); "VALUE" L,U,I,J,C,S;
     "INTEGER" L,U,I,J; "REAL" C,S; "ARRAY" A;
     "CODE" 34041;
 
     FORMAL PARAMETERS:
     L,U:    <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE RUNNING SUBSCRIPT;
     I,J:    <ARITHMETIC EXPRESSION>;
             ROW-INDICES OF THE ROW-VECTORS OF ARRAY A;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[P : Q, L : U]; P AND Q SHOULD SATISFY:  P  <=  I,
             P <= J, Q >= I AND Q >= J;
     C,S:    <ARITHMETIC EXPRESSION>;
             ROTATION FACTORS.
 
 
 LANGUAGE: COMPASS.
 
 
 REFERENCES:
 
     [1].T.J.DEKKER.
         ALGOL 60 PROCEDURES IN NUMERICAL ALGEBRA, PART 1,
         MATHEMATICAL CENTRE TRACT 22, AMSTERDAM (1970).
1SECTION : 1.1.7              (DECEMBER 1979)                     PAGE 3
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES ARE WRITTEN IN COMPASS, AN EQUIVALENT ALGOL 60
 TEXT OF THESE COMPASS ROUTINES IS GIVEN.
 
 
 
 
 
 "CODE" 34040;
     "PROCEDURE" ROTCOL(L, U, I, J, A, C, S); "VALUE" L,U,I,J,C,S;
     "INTEGER" L,U,I,J; "REAL" C,S; "ARRAY" A;
     "BEGIN" "REAL" X, Y;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" X:= A[L,I]; Y:= A[L,J]; A[L,I]:= X * C + Y * S;
             A[L,J]:= Y * C - X * S
         "END"
     "END" ROTCOL;
         "EOP"
 
 "CODE" 34041;
     "PROCEDURE" ROTROW(L, U, I, J, A, C, S); "VALUE" L,U,I,J,C,S;
     "INTEGER" L,U,I,J; "REAL" C,S; "ARRAY" A;
     "BEGIN" "REAL" X, Y;
         "FOR" L:= L "STEP" 1 "UNTIL" U "DO"
         "BEGIN" X:= A[I,L]; Y:= A[J,L]; A[I,L]:= X * C + Y * S;
             A[J,L]:= Y * C - X * S
         "END"
     "END" ROTROW;
         "EOP"
1SECTION : 1.1.4.2            (DECEMBER 1979)                     PAGE 1
 
 
 
 AUTHOR : D.WINTER.
 
 
 INSTITUTE : MATHEMATICAL CENTRE.
 
 
 RECEIVED : 741215.
 
 
 BRIEF DESCRIPTION :
 
     THIS SECTION CONTAINS FIVE PROCEDURES :
     FULMATVEC CALCULATES THE VECTOR A * B, WHERE A IS A GIVEN MATRIX
     AND B IS A VECTOR.
     FULTAMVEC CALCULATES THE VECTOR A' * B, WHERE A' IS THE TRANSPOSED
     OF THE MATRIX A AND B IS A VECTOR.
     FULSYMMATVEC CALCULATES THE VECTOR A * B, WHERE A IS A SYMMETRIC
     MATRIX WHOSE UPPERTRIANGLE IS STORED COLUMNWISE IN A
     ONE-DIMENSIONAL ARRAY AND B IS A VECTOR.
     RESVEC CALCULATES THE RESIDUAL VECTOR A * B + X * C, WHERE A IS A
     GIVEN MATRIX, B AND C ARE VECTORS AND X IS A SCALAR.
     SYMRESVEC CALCULATES THE RESIDUAL VECTOR A * B + X * C, WHERE A IS
     A SYMMETRIC MATRIX WHOSE UPPERTRIANGLE IS STORED IN A
     ONE-DIMENSIONAL ARRAY, B AND C ARE VECTORS AND X IS A SCALAR.
 
 
 KEYWORDS :
 
     ELEMENTARY PROCEDURE,
     VECTOR OPERATION.
1SECTION : 1.1.4.2            (DECEMBER 1975)                     PAGE 2
 
 
 
 SUBSECTION: FULMATVEC.
 
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE READS:
     "PROCEDURE" FULMATVEC(LR, UR, LC, UC, A, B, C);
     "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
     "ARRAY" A, B, C;
     "CODE" 31500;
 
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     LR, UR: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE ROW-INDEX;
     LC, UC: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE COLUMN-INDEX;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[LR:UR,LC:UC]; THE MATRIX;
     B:      <ARRAY IDENTIFIER>;
             "ARRAY" B[LC:UC]; THE VECTOR;
     C:      <ARRAY IDENTIFIER>;
             "ARRAY" C[LR:UR];
             THE RESULT A * B IS DELIVERED IN C.
 
 
 LANGUAGE:   COMPASS 3.
 
 METHOD AND PERFORMANCE: SEE REFERENCE [1].
 
 SUBSECTION: FULTAMVEC.
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE READS:
     "PROCEDURE" FULTAMVEC(LR, UR, LC, UC, A, B, C);
     "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
     "ARRAY" A, B, C;
     "CODE" 31501;
 
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     LR, UR: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE ROW-INDEX;
     LC, UC: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE COLUMN-INDEX;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[LR:UR,LC:UC]; THE MATRIX;
     B:      <ARRAY IDENTIFIER>;
            "ARRAY" B[LR:UR]; THE VECTOR;
     C:      <ARRAY IDENTIFIER>;
             "ARRAY" C[LC:UC];
             THE RESULT A' * B IS DELIVERED IN C; HERE A' DENOTES THE
             TRANSPOSED OF THE MATRIX A.
 
1SECTION : 1.1.4.2            (DECEMBER 1975)                     PAGE 3
 
 
 
 LANGUAGE:   COMPASS 3.
 
 
 METHOD AND PERFORMANCE: ELEMENTARY.
 
 
 SUBSECTION: FULSYMMATVEC.
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE READS:
     "PROCEDURE" FULSYMMATVEC(LR, UR, LC, UC, A, B, C);
     "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
     "ARRAY" A, B, C;
     "CODE" 31502;
 
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     LR, UR: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE ROW-INDEX; LR >= 1;
     LC, UC: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE COLUMN-INDEX; LC >= 1;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[L:U], WHERE:
             L = MIN(LR * (LR - 1) // 2 + LC, LC * (LC - 1) // 2 + LR),
             U = MAX(UR * (UR - 1) // 2 + UC, UC * (UC - 1) // 2 + UR)
             AND THE (I,J)-TH ELEMENT OF THE SYMMETRIC MATRIX SHOULD BE
             GIVEN IN A[J * (J - 1) // 2 + I];
     B:      <ARRAY IDENTIFIER>;
             "ARRAY" B[LC:UC]; THE VECTOR;
     C:      <ARRAY IDENTIFIER>;
             "ARRAY" C[LR:UR];
             THE RESULT A * B IS DELIVERED IN C.
 
 
1SECTION : 1.1.4.2            (DECEMBER 1975)                     PAGE 4
 
 
 
 PROCEDURES USED:
 
     SYMMATVEC = CP34018.
 
 
 LANGUAGE:   ALGOL 60.
 
 
 METHOD AND PERFORMANCE:
 
     ELEMENTARY.
 
 
 SUBSECTION: RESVEC.
 
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE READS:
     "PROCEDURE" RESVEC(LR, UR, LC, UC, A, B, C, X);
     "VALUE" LR, UR, LC, UC, B, X; "INTEGER" LR, UR, LC, UC;
     "REAL" X; "ARRAY" A, B, C;
     "CODE" 31503;
 
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     LR, UR: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE ROW-INDEX;
     LC, UC: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE COLUMN-INDEX;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[LR:UR,LC:UC]; THE MATRIX;
     B:      <ARRAY IDENTIFIER>;
             "ARRAY" B[LC:UC]; THE VECTOR;
     X:      <ARITHMETIC EXPRESSION>;
             THE VALUE OF THE MULTIPLYING SCALAR;
     C:      <ARRAY IDENTIFIER>;
             "ARRAY" C[LR:UR];
             THE RESULT A * B + X * C IS OVERWRITTEN ON C.
 
 
 LANGUAGE:   COMPASS 3.
 
 
 METHOD AND PERFORMANCE:
 
     ELEMENTARY.
 
 
1SECTION : 1.1.4.2            (DECEMBER 1975)                     PAGE 5
 
 
 
 SUBSECTION: SYMRESVEC.
 
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE READS:
     "PROCEDURE" SYMRESVEC(LR, UR, LC, UC, A, B, C, X);
     "VALUE" LR, UR, LC, UC, B, X; "INTEGER" LR, UR, LC, UC;
     "REAL" X; "ARRAY" A, B, C;
     "CODE" 31504;
 
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     LR, UR: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE ROW-INDEX; LR >= 1;
     LC, UC: <ARITHMETIC EXPRESSION>;
             LOWER AND UPPER BOUND OF THE COLUMN-INDEX; LC >= 1;
     A:      <ARRAY IDENTIFIER>;
             "ARRAY" A[L:U], WHERE:
             L = MIN(LR * (LR - 1) // 2 + LC, LC * (LC - 1) // 2 + LR),
             U = MAX(UR * (UR - 1) // 2 + UC, UC * (UC - 1) // 2 + UR)
             AND THE (I,J)-TH ELEMENT OF THE SYMMETRIC MATRIX SHOULD BE
             GIVEN IN A[J * (J - 1) // 2 + I];
     B:      <ARRAY IDENTIFIER>;
             "ARRAY" B[LC:UC]; THE VECTOR;
     X:      <ARITHMETIC EXPRESSION>;
             THE VALUE OF THE MULTIPLYING SCALAR;
     C:      <ARRAY IDENTIFIER>;
             "ARRAY" C[LR:UR];
             THE RESULT A * B  + X * C IS DELIVERED IN C.
 
 
 PROCEDURES USED:
 
     SYMMATVEC = CP34018.
 
 
 LANGUAGE:   ALGOL 60.
 
 
 METHOD AND PERFORMANCE:
 
     ELEMENTARY.
 
 
 REFERENCES:
 
     [1].T.J.DEKKER.
         ALGOL 60 PROCEDURES IN NUMERICAL ALGEBRA, PART1,
         MATHEMATICAL CENTRE TRACT 22, AMSTERDAM (1970).
 
     [2].J.C.P.BUS.
         MINIMALISERING VAN FUNKTIES VAN MEERDERE VARIABELEN,
         MATHEMATICAL CENTRE, NR 29/72, AMSTERDAM (1972).
1SECTION : 1.1.4.2            (DECEMBER 1975)                     PAGE 6
 
 
 
 SOURCE TEXT(S):
 
 THE FOLLOWING PROCEDURES, EXCEPT FOR FULSYMMATVEC AND SYMRESVEC ARE
 WRITTEN IN COMPASS 3, AN EQUIVALENT ALGOL TEXT OF THESE COMPASS
 ROUTINES IS GIVEN.
0"CODE" 31500;
    "PROCEDURE" FULMATVEC(LR, UR, LC, UC, A, B, C);
    "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
    "ARRAY" A, B, C;
    "BEGIN" "REAL" "PROCEDURE" MATVEC(L, U, I, A, B); "CODE" 34011;
        "FOR" LR:= LR "STEP" 1 "UNTIL" UR "DO"
        C[LR]:= MATVEC(LC, UC, LR, A, B);
    "END" FULMATVEC;
         "EOP"
0"CODE" 31501;
    "PROCEDURE" FULTAMVEC(LR, UR, LC, UC, A, B, C);
    "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
    "ARRAY" A, B, C;
    "BEGIN" "REAL" "PROCEDURE" TAMVEC(L, U, I, A, B); "CODE" 34012;
        "FOR" LC:= LC "STEP" 1 "UNTIL" UC "DO"
        C[LC]:= TAMVEC(LR, UR, LC, A, B);
    "END" FULTAMVEC;
         "EOP"
0"CODE" 31502;
    "PROCEDURE" FULSYMMATVEC(LR, UR, LC, UC, A, B, C);
    "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
    "ARRAY" A, B, C;
    "BEGIN" "REAL" "PROCEDURE" SYMMATVEC(L, U, I, A, B);
        "CODE" 34018;
        "FOR" LR:= LR "STEP" 1 "UNTIL" UR "DO"
        C[LR]:= SYMMATVEC(LC, UC, LR, A, B)
    "END" FULSYMMATVEC;
         "EOP"
0"CODE" 31503;
    "PROCEDURE" RESVEC(LR, UR, LC, UC, A, B, C, X);
    "VALUE" LR, UR, LC, UC, X; "INTEGER" LR, UR, LC, UC;
    "REAL" X; "ARRAY" A, B, C;
    "BEGIN" "REAL" "PROCEDURE" MATVEC(L, U, I, A, B); "CODE" 34011;
        "FOR" LR:= LR "STEP" 1 "UNTIL" UR "DO"
        C[LR]:= MATVEC(LC, UC, LR, A, B) + C[LR] * X
    "END" RESVEC;
         "EOP"
0"CODE" 31504;
    "PROCEDURE" SYMRESVEC(LR, UR, LC, UC, A, B, C, X);
    "VALUE" LR, UR, LC, UC, X; "INTEGER" LR, UR, LC, UC;
    "REAL" X; "ARRAY" A, B, C;
    "BEGIN" "REAL" "PROCEDURE" SYMMATVEC(L, U, I, A, B);
        "CODE" 34018;
        "FOR" LR:= LR "STEP" 1 "UNTIL" UR "DO"
       C[LR]:= SYMMATVEC(LC, UC, LR, A, B) + C[LR] * X
    "END" SYMRESVEC;
         "EOP"
1SECTION : 1.1.9              (APRIL 1974)                        PAGE 1
 
 
 
 AUTHORS  : T.J. DEKKER, W. HOFFMANN.
 
 
 CONTRIBUTORS: W. HOFFMANN, S.P.N. VAN KAMPEN.
 
 
 INSTITUTE: MATHEMATICAL CENTRE.
 
 
 RECEIVED: 731030.
 
 
 BRIEF DESCRIPTION:
 
     THE PROCEDURE REASCL  NORMALIZES THE  (NON-NULL) COLUMNS  OF A TWO-
     DIMENSIONAL ARRAY IN SUCH A WAY THAT, IN EACH COLUMN, AN ELEMENT OF
     MAXIMUM  ABSOLUTE  VALUE  EQUALS  1.  THE  NORMALIZED  VECTORS  ARE
     DELIVERED IN THE CORRESPONDING COLUMNS OF THE ARRAY.
 
 
 KEYWORDS:
 
     NORMALIZATION,
     VECTOR SCALING.
 
 
 CALLING SEQUENCE:
 
     THE HEADING OF THE PROCEDURE IS:
     "PROCEDURE" REASCL(A, N, N1, N2); "VALUE" N, N1, N2;
     "INTEGER" N, N1, N2; "ARRAY" A;
 
     THE MEANING OF THE FORMAL PARAMETERS IS:
     A:      <ARRAY IDENTIFIER>;
             A TWO-DIMENSIONAL ARRAY A[1:N,N1:N2];
             ENTRY: THE  N2 - N1 + 1  COLUMN VECTORS MUST BE GIVEN IN A;
             EXIT:  THE NORMALIZED  VECTORS (I.E. IN  EACH VECTOR AN
                    ELEMENT  OF MAXIMUM  ABSOLUTE  VALUE  EQUALS 1)  ARE
                    DELIVERED IN THE CORRESPONDING COLUMNS OF A;
     N:      <ARITHMETIC EXPRESSION>;
             THE NUMBER OF ROWS OF ARRAY A;
     N1, N2: <ARITHMETIC EXPRESSION>;
             THE LOWER AND UPPER BOUND OF THE COLUMN INDICES OF ARRAY A.
 
1SECTION : 1.1.9              (APRIL 1974)                        PAGE 2
 
 
 
 PROCEDURES USED: NONE.
 
 
 
 
 RUNNING TIME: PROPORTIONAL TO N * (N2 - N1 + 1).
 
 
 LANGUAGE:   ALGOL 60.
 
 
 METHOD AND PERFORMANCE: SEE REF [1].
 
 
 REFERENCES:
     [1].T.J. DEKKER AND W. HOFFMANN.
         ALGOL 60 PROCEDURES IN NUMERICAL ALGEBRA, PART 2.
         MC TRACT 23, 1968, MATH. CENTR., AMSTERDAM.
 
 
 EXAMPLE OF USE:
 
     THE PROCEDURE REASCL IS USED IN REAEIG1, SECTION 3.3.1.2.2.
 
 
0SOURCE TEXT(S) :
 
 "CODE" 34183;
     "COMMENT" MCA 2413;
     "PROCEDURE" REASCL(A, N, N1, N2); "VALUE" N, N1, N2;
     "INTEGER" N, N1, N2; "ARRAY" A;
     "BEGIN" "INTEGER" I, J; "REAL" S;
         "FOR" J:= N1 "STEP" 1 "UNTIL" N2 "DO"
         "BEGIN" S:= 0;
             "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"
             "IF" ABS(A[I,J]) > ABS(S) "THEN" S:= A[I,J];
             "IF" S ^= 0 "THEN"
             "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO" A[I,J]:= A[I,J] / S
         "END"
     "END" REASCL;
         "EOP"
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 1      
        
        
        
 AUTHOR: J.C.P.BUS.         
        
        
 INSTITUTE: MATHEMATICAL CENTRE.      
        
        
 RECEIVED: 730620.
        
        
 BRIEF DESCRIPTION:         
        
     THIS SECTION CONTAINS TWO PROCEDURES, RNK1MIN AND FLEMIN, FOR  
     MINIMIZING A GIVEN DIFFERENTIABLE FUNCTION OF SEVERAL VARIABLES;         
     BOTH PROCEDURES USE A VARIABLE METRIC METHOD; THE USER HAS TO  
     PROGRAM THE EVALUATION OF THE FUNCTION AND ITS GRADIENT;       
     THE CHOICE OF RNK1MIN AND FLEMIN IS DEPENDENT ON THE PROBLEM   
     INVOLVED; IF THE NUMBER OF VARIABLES OF THE FUNCTION TO BE     
     MINIMIZED IS VERY LARGE AND THE CALCULATION OF THE FUNCTION AND ITS      
     GRADIENT IS RELATIVELY CHEAP (THE NUMBER OF ARITHMETIC OPERATIONS        
     IS OF ORDER AT MOST N ** 2),THEN THE USER IS ADVISED TO USE FLEMIN;      
     IF THE HESSIAN OF THE FUNCTION IS EXPECTED TO BE (ALMOST) SINGULAR       
     AT THE MINIMUM, THEN RNK1MIN IS PREFERRED; 
        
        
 KEYWORDS:        
        
     OPTIMIZATION,
     HIGHER - DIMENSIONAL,  
     UNCONSTRAINED,         
     VARIABLE METRIC METHOD.
        
        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 2      
        
        
        
 SUBSECTION: RNK1MIN.       
        
        
 CALLING SEQUENCE:
        
     THE HEADING OF THIS PROCEDURE IS:
     "REAL" "PROCEDURE" RNK1MIN(N, X, G, H, FUNCT, IN, OUT);        
     "VALUE" N; "INTEGER" N;
     "ARRAY" X, G, H, IN, OUT;        
     "REAL" "PROCEDURE" FUNCT;        
        
     RNK1MIN: DELIVERS THE CALCULATED LEAST VALUE OF THE GIVEN FUNCTION;      
        
     THE MEANING OF THE FORMAL PARAMETERS IS:   
     N:      <ARITHMETIC EXPRESSION>; 
             THE NUMBER OF VARIABLES OF THE FUNCTION TO BE MINIMIZED;         
     X:      <ARRAY IDENTIFIER>;      
             "ARRAY" X[1 : N];        
             THE INDEPENDENT VARIABLES;         
             ENTRY:  AN APPROXIMATION OF A MINIMUM OF THE FUNCTION; 
             EXIT:   THE CALCULATED MINIMUM OF THE FUNCTION;        
     G:      <ARRAY IDENTIFIER>;      
             "ARRAY" G[1 : N];        
             EXIT:   THE GRADIENT  OF  THE FUNCTION  AT  THE  CALCULATED      
                     MINIMUM;         
     H:      <ARRAY IDENTIFIER>;      
             "ARRAY" H[1 : N * (N + 1) // 2];   
             THE  UPPERTRIANGLE  OF  AN  APPROXIMATION  OF  THE  INVERSE      
             HESSIAN IS STORED COLUMNWISE IN H (I.E. THE I,J-TH ELEMENT=      
             H[ (J - 1) * J // 2 + I], 1 <= I<= J <= N ); 
             IF  IN[6] > 0  INITIALIZING OF H WILL BE DONE AUTOMATICALLY      
             AND  THE INITIAL APPROXIMATION  OF THE INVERSE HESSIAN WILL      
             EQUAL THE UNITMATRIX MULTIPLIED WITH THE VALUE OF IN[6];         
             IF IN[6] < 0 NO INITIALIZING OF H WILL BE DONE AND THE USER      
             SHOULD GIVE IN  H  AN APPROXIMATION OF THE INVERSE HESSIAN,      
             AT THE STARTING POINT;THE UPPERTRIANGLE OF AN APPROXIMATION      
             OF  THE  INVERSE  HESSIAN  AT  THE  CALCULATED  MINIMUM  IS      
             DELIVERED IN H;
     FUNCT:  <PROCEDURE IDENTIFIER>;  
             THE HEADING OF THIS PROCEDURE SHOULD BE:     
             "REAL" "PROCEDURE" FUNCT(N, X, G); "VALUE" N;
             "INTEGER" N; "ARRAY" X, G;         
             A CALL OF FUNCT MUST EFFECTUATE IN:
             1:  FUNCT BECOMES THE VALUE OF THE FUNCTION TO BE MINIMIZED      
                 AT THE POINT X;      
             2:  THE VALUE OF G[I], (I = 1, ..., N),  BECOMES  THE VALUE      
                 OF THE I - TH COMPONENT OF THE GRADIENT OF THE FUNCTION      
                 AT X;      
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 3      
        
        
        
     IN:     <ARRAY IDENTIFIER>;      
             "ARRAY" IN[0 : 8];       
             ENTRY:         
             IN[0]:  THE MACHINE PRECISION;     
                     FOR THE CYBER 73-26 A SUITABLE VALUE IS "-14;  
             IN[1]:  THE RELATIVE TOLERANCE FOR THE SOLUTION;       
                     THIS TOLERANCE SHOULD  NOT  BE CHOSEN  SMALLER THAN      
                     IN[0]; 
             IN[2]:  THE ABSOLUTE TOLERANCE FOR THE SOLUTION;       
             IN[3];  A PARAMETER USED FOR  CONTROLLING LINEMINIMIZATION,      
                     ([3], [4]); USUALLY A SUITABLE VALUE IS: 0.0001;         
             IN[4]:  THE ABSOLUTE  TOLERANCE  FOR  THE EUCLIDEAN NORM OF      
                     THE GRADIENT AT THE SOLUTION;        
             IN[5]:  A LOWERBOUND FOR THE FUNCTIONVALUE;  
             IN[6]:  THIS PARAMETER  CONTROLS  THE INITIALIZATION OF THE      
                     APPROXIMATION  OF  THE  INVERSE  HESSIAN  (METRIC),      
                     SEE H; USUALLY THE CHOICE IN[6] = 1  WILL GIVE GOOD      
                     RESULTS;         
             IN[7]:  THE MAXIMUM ALLOWED NUMBER OF CALLS OF FUNCT;  
             IN[8]:  A PARAMETER USED FOR  CONTROLLING  THE UPDATING  OF      
                     THE METRIC; IT IS USED  TO AVOID  UNBOUNDEDNESS  OF      
                     THE METRIC (SEE: [6], FORMULA (19)); 
                     THE VALUE OF IN[8] SHOULD SATISFY:   
                     SQRT(IN[0] / IN[1]) / N < IN[8] < 1; 
                     USUALLY A SUITABLE VALUE WILL BE 0.01;         
     OUT:    <ARRAY IDENTIFIER>;      
             "ARRAY" OUT[0:4];        
             EXIT:
             OUT[0]: THE EUCLIDEAN NORM OF THE PRODUCT OF THE METRIC AND      
                     THE GRADIENT AT THE CALCULATED MINIMUM;        
             OUT[1]: THE  EUCLIDEAN  NORM   OF   THE  GRADIENT   AT  THE      
                     CALCULATED MINIMUM;        
             OUT[2]: THE NUMBER OF CALLS OF FUNCT,  NECESSARY  TO ATTAIN      
                     THIS RESULT;     
             OUT[3]: THE NUMBER OF ITERATIONS  IN WHICH A LINESEARCH WAS      
                     NECESSARY;       
             OUT[4]: THE NUMBER OF ITERATIONS  IN WHICH A DIRECTION  HAD      
                     TO  BE  CALCULATED  WITH  THE METHOD  GIVEN IN [5];      
                     IN  SUCH  AN  ITERATION   A    CALCULATION  OF  THE      
                     EIGENVALUES  AND  EIGENVECTORS  OF  THE  METRIC  IS      
                     NECESSARY.       
        
 DATA AND RESULTS:
        
     USUALLY THE CALCULATED SOLUTION WILL SATISFY:        
     NORM ( XMIN - XCAL ) < NORM ( XCAL ) * IN[1] + IN[2].
     WHERE AT  XMIN THE GIVEN FUNCTION IS MINIMAL,  XCAL THE  CALCULATED      
     APPROXIMATION OF XMIN AND NORM( . ) DENOTES THE EUCLIDEAN NORM 
     OF X;  HOWEVER,  WE CANNOT GUARANTEE SUCH A RESULT;  THE CALCULATED      
     SOLUTION  POSSIBLY WILL  NOT  SATISFY  THE ABOVE INEQUALITY  IF THE      
     PROBLEM IS VERY ILL - CONDITIONED;  THE USER  CAN DISCOVER  SUCH  A      
     SITUATION BY LOOKING AT THE EUCLIDEAN NORM OF THE METRIC, DELIVERED      
     IN H; THE PROBLEM IS ILL - CONDITIONED IF  THIS  NORM  IS  LARGE         
     RELATIVE TO 1.         
        
        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 4      
        
        
        
 PROCEDURES USED: 
        
     VECVEC = CP34010,      
     MATVEC = CP34011,      
     TAMVEC = CP34012,      
     SYMMATVEC = CP34018,   
     INIVEC = CP31010,      
     INISYMD = CP31013,     
     MULVEC = CP31020,      
     DUPVEC = CP31030,      
     EIGSYM1 = CP34156,     
     LINEMIN = CP34210,     
     RNK1UPD = CP34211,     
     DAVUPD = CP34212,      
     FLEUPD = CP34213.      
        
        
 REQUIRED CENTRAL MEMORY:   
        
     EXECUTION FIELD LENGTH: VARIES FROM 5 * N + 26 TO    
                         N ** 2 + N * (N + 1) // 2 + 5 * N + 35 WORDS.        
        
        
 RUNNING TIME:    
        
     DEPENDS STRONGLY ON THE PROBLEM TO BE SOLVED;        
        
        
 LANGUAGE:   ALGOL 60.      
        
        
 METHOD AND PERFORMANCE:    
        
     RNK1MIN  CALCULATES  AN APPROXIMATION  OF  A  MINIMUM  OF  A  GIVEN      
     FUNCTION  BY  MEANS  OF  A  VARIABLE METRIC METHOD;  THE RANK - ONE      
     UPDATING  FORMULA,  USED  IN  THIS  ALGORITHM   IS  GIVEN  IN  [6],      
     (FORMULA (4));  TO AVOID  UNBOUNDEDNESS  OF  THE  METRIC (SEE [8]),      
     SOMETIMES  A  RANK - TWO UPDATING  FORMULA IS USED  ([3],      
     FORMULAS (1) AND (5)); TO AVOID LINESEARCHES AS MUCH AS POSSIBLE  A      
     STRATEGY GIVEN IN [4] IS USED;  IF IN AN ITERATION  THE FUNCTION IS      
     INCREASING IN THE DIRECTION GIVEN BY THE VARIABLE METRIC ALGORITHM,      
     BECAUSE THE METRIC IS NOT POSITIVE DEFINITE, THEN A METHOD GIVEN IN      
     [5] IS USED TO CALCULATE A NEW DIRECTION;  THIS METHOD REQUIRES
     THE CALCULATION OF THE EIGENVECTORS  AND EIGENVALUES OF THE METRIC;      
     USUALLY,THE NUMBER OF TIMES SUCH A CALCULATION IS NECESSARY IS VERY      
     SMALL RELATIVE TO THE NUMBER OF ITERATIONS (AND OFTEN EQUALS ZERO);      
     IF THE NUMBER OF VARIABLES  OF THE FUNCTION  IS  VERY LARGE AND THE      
     CALCULATION OF THE FUNCTION  AND  ITS GRADIENT  IS RELATIVELY CHEAP      
     (THE NUMBER OF ARITHMETICAL OPERATIONS IS OF ORDER AT MOST N ** 2),      
     THEN THE USER IS ADVISED TO USE FLEMIN (CP32105);    
     A DETAILED DESCRIPTION OF THE ALGORITHM  AND SOME RESULTS ABOUT ITS      
     CONVERGENCE IS GIVEN IN [1].     
        
        
        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 5      
        
        
        
 SUBSECTION: FLEMIN.        
        
        
 CALLING SEQUENCE:
        
     THE HEADING OF THIS PROCEDURE IS:
     "REAL" "PROCEDURE" FLEMIN(N, X, G, H, FUNCT, IN, OUT);         
     "VALUE" N; "INTEGER" N;
     "ARRAY" X, G, H, IN, OUT; "REAL" "PROCEDURE" FUNCT;  
        
     FLEMIN: DELIVERS THE CALCULATED LEAST VALUE OF THE GIVEN FUNCTION;       
        
     THE MEANING OF THE FORMAL PARAMETERS IS:   
     N:      <ARITHMETIC EXPRESSION>; 
             THE NUMBER OF VARIABLES OF THE FUNCTION TO BE MINIMIZED;         
     X:      <ARRAY IDENTIFIER>;      
             "ARRAY" X[1 : N];        
             THE INDEPENDENT VARIABLES;         
             ENTRY:  AN APPROXIMATION OF A MINIMUM OF THE FUNCTION; 
             EXIT:   THE CALCULATED MINIMUM OF THE FUNCTION;        
     G:      <ARRAY IDENTIFIER>;      
             "ARRAY" G[1 : N];        
             EXIT:   THE GRADIENT  OF  THE  FUNCTION  AT  THE CALCULATED      
                     MINIMUM;         
     H:      <ARRAY IDENTIFIER>;      
             "ARRAY" H[1 : N * (N + 1) // 2];   
             THE  UPPERTRIANGLE  OF  AN  APPROXIMATION  OF  THE  INVERSE      
             HESSIAN IS STORED COLUMNWISE IN H (I.E. THE I,J-TH ELEMENT=      
             H[ )J - 1) * J // 2 + I], 1 <= I <= J <= N); 
             IF IN[6] > 0  INITIALIZING OF  H WILL BE DONE AUTOMATICALLY      
             AND  THE INITIAL APPROXIMATION  OF THE INVERSE HESSIAN WILL      
             EQUAL THE UNITMATRIX MULTIPLIED WITH THE VALUE OF IN[6]; IF      
             IN[6] < 0  NO INITIALIZING OF  H  WILL BE DONE AND THE USER      
             SHOULD GIVE IN  H  AN APPROXIMATION OF  THE INVERSE HESSIAN      
             AT THE STARTING POINT;   
             THE  UPPERTRIANGLE  OF  AN  APPROXIMATION  OF  THE  INVERSE      
             HESSIAN AT THE CALCULATED MINIMUM IS DELIVERED IN H;   
     FUNCT:  <PROCEDURE IDENTIFIER>;  
             THE HEADING OF THIS PROCEDURE SHOULD BE :    
             "REAL" "PROCEDURE" FUNCT(N, X, G); "VALUE" N;
             "INTEGER" N; "ARRAY" X, G;         
             A CALL OF FUNCT SHOULD EFFECTUATE IN:        
             1:  FUNCT BECOMES THE VALUE OF THE FUNCTION TO BE MINIMIZED      
                 AT THE POINT X;      
             2:  THE VALUE OF G[I], (I = 1, ..., N),  BECOMES  THE VALUE      
                 OF THE I - TH COMPONENT OF THE GRADIENT OF THE FUNCTION      
                 AT X;      
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 6      
        
        
        
     IN:     <ARRAY IDENTIFIER>;      
             "ARRAY" IN[1 : 7];       
             ENTRY:         
             IN[1]:  THE RELATIVE TOLERANCE FOR THE SOLUTION;       
             IN[2]:  THE ABSOLUTE TOLERANCE FOR THE SOLUTION;       
             IN[3]:  A PARAMETER  USED FOR CONTROLLING LINEMINIMIZATION       
                     ([3], [4]); USUALLY A SUITABLE VALUE IS 0.0001;
             IN[4]:  THE ABSOLUTE TOLERANCE  FOR  THE EUCLIDEAN  NORM OF      
                     THE GRADIENT AT THE SOLUTION;        
             IN[5]:  A LOWERBOUND FOR THE FUNCTION VALUE; 
             IN[6]:  THIS  PARAMETER  CONTROLS THE INITIALIZATION OF THE      
                     APPROXIMATION OF THE INVERSE HESSIAN (METRIC) (SEE       
                     H); USUALLY IN[6] = 1 WILL GIVE GOOD RESULTS;  
             IN[7]:  THE MAXIMUM ALLOWED NUMBER OF CALLS OF FUNCT;  
     OUT:    <ARRAY IDENTIFIER>;      
             "ARRAY" OUT[0:4];        
             EXIT:
             OUT[0]: THE EUCLIDEAN NORM OF THE PRODUCT OF THE METRIC AND      
                     THE GRADIENT AT THE CALCULATED MINIMUM;        
             OUT[1]: THE  EUCLIDEAN  NORM    OF  THE  GRADIENT  AT   THE      
                     CALCULATED MINIMUM;        
             OUT[2]: THE NUMBER OF CALLS OF FUNCT,  NECESSARY  TO ATTAIN      
                     THESE RESULTS;   
             OUT[3]: THE NUMBER OF ITERATIONS IN WHICH A LINESEARCH  WAS      
                     NECESSARY;       
             OUT[4]: IF OUT[4] = - 1,  THEN  THE  PROCESS  IS BROKEN OFF      
                     BECAUSE  NO DOWNHILL DIRECTION COULD BE CALCULATED;      
                     THE PRECISION  ASKED FOR MAY NOT BE ATTAINED AND IS      
                     POSSIBLY CHOSEN TOO HIGH;  
                     NORMALLY OUT[4] = 0;       
        
        
 DATA AND RESULTS:
        
     USUALLY THE CALCULATED SOLUTION WILL SATISFY:        
     NORM ( XMIN - XCAL ) < NORM ( XCAL ) * IN[1] + IN[2].
     WHERE AT XMIN THE GIVEN FUNCTION IS MINIMAL,  XCAL THE  CALCULATED       
     APPROXIMATION OF XMIN AND NORM ( . )  DENOTES THE EUCLIDEAN  NORM        
     OF X;  HOWEVER, WE CAN NOT GUARANTEE SUCH A RESULT;  THE CALCULATED      
     SOLUTION POSSIBLY WILL NOT SATISFY  THE  ABOVE  INEQUALITY  IF  THE      
     PROBLEM IS VERY ILL - CONDITIONED;  THE  USER  CAN  DISCOVER SUCH A      
     SITUATION BY LOOKING AT THE EUCLIDEAN NORM OF THE METRIC, DELIVERED      
     IN H;  THE  PROBLEM IS ILL - CONDITIONED  IF  THIS  NORM  IS  LARGE      
     RELATIVE TO 1.         
        
        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 7      
        
        
        
 PROCEDURES USED: 
        
     VECVEC = CP34010,      
     ELMVEC = CP34020,      
     SYMMATVEC = CP34018,   
     INIVEC = CP31010,      
     INISYMD = CP31013,     
     MULVEC = CP31020,      
     DUPVEC = CP31030,      
     LINEMIN = CP34210,     
     DAVUPD = CP34212,      
     FLEUPD = CP34213.      
        
        
 REQUIRED CENTRAL MEMORY:   
        
     EXECUTION FIELD LENGTH: 3 * N + 19 WORDS.  
        
        
 RUNNING TIME:    
        
     DEPENDS STRONGLY ON THE PROBLEM TO BE SOLVED;        
        
        
 LANGUAGE:   ALGOL 60.      
        
        
 METHOD AND PERFORMANCE:    
        
     FLEMIN CALCULATES AN APPROXIMATION OF A MINIMUM OF A GIVEN FUNCTION      
     BY MEANS OF THE VARIABLE METRIC ALGORITHM GIVEN IN [3],  EXCEPT FOR      
     SOME DETAILS (SEE [1]).
        
 REFERENCES:      
     [1] BUS, J. C. P.      
         MINIMIZATION OF FUNCTIONS OF SEVERAL VARIABLES (DUTCH).    
         MATHEMATICAL CENTRE, AMSTERDAM, NR 29/72 (1972). 
     [2] DAVIDON, W. C.     
         VARIABLE METRIC METHOD FOR MINIMIZATION.         
         ARGONNE NAT. LAB. REPORT, ANL 5990 (1959).       
     [3] FLETCHER, R.       
         A NEW APPROACH TO VARIABLE METRIC ALGORITHMS.    
         COMP. J. 6, (1963), P.163 - 168.       
     [4] GOLDSTEIN, A. A. AND PRICE, J. F.      
         AN EFFECTIVE ALGORITHM FOR MINIMIZATION.         
         NUMER. MATH. 10, (1967), P.184 - 189.  
     [5] GREENSTADT, J. L.  
         ON THE RELATIVE EFFICIENCIES OF GRADIENT METHODS.
         MATH. COMP. 21, (1967), P.360 - 367.   
     [6] POWELL, M. J. D.   
         RANK ONE METHODS FOR UNCONSTRAINED OPTIMIZATION. 
         IN: ABADIE, J. (ED.)         
             INTEGER AND NONLINEAR PROGRAMMING. 
             NORTH - HOLLAND, (1970). 
        
        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 8      
        
        
        
        
 EXAMPLE OF USE:  
        
     THE MINIMUM OF THE FUNCTION:     
     F(X) = (X[2] - X[1] ** 2) ** 2 * 100 + (1 - X[1]) ** 2,        
     CALCULATED WITH BOTH  RNK1MIN  AND  FLEMIN  MAY  BE OBTAINED BY THE      
     FOLLOWING PROGRAM:     
        
 "BEGIN"
     "REAL" "PROCEDURE" RNK1MIN(N, X, G, H, FUNCT, IN, OUT);        
     "CODE" 34214;
     "REAL" "PROCEDURE" FLEMIN(N, X, G, H, FUNCT, IN, OUT);         
     "CODE" 34215;
     "REAL" "PROCEDURE" ROSENBROCK(N, X, G); "VALUE" N;   
     "INTEGER" N; "ARRAY" X, G;       
     "BEGIN" ROSENBROCK:= (X[2] - X[1] ** 2) ** 2 * 100   
         + (1 - X[1]) ** 2; 
         G[1]:= ((X[1] ** 2 - X[2]) * 400 + 2) * X[1] - 2;
         G[2]:=(X[2] - X[1] ** 2) * 200         
     "END" ROSENBROCK;      
     "INTEGER" I; "BOOLEAN" AGAIN; "REAL" F;    
     "ARRAY" X, G[1:2], H[1:3], IN[0:8], OUT[0:4];        
        
     IN[0]:= "-14; IN[1]:= "-5; IN[2]:= "-5; IN[3]:= "-4; 
     IN[4]:= "-5; IN[5]:= -10; IN[6]:= 1; IN[7]:= 100; IN[8]:= 0.01;
     X[1]:= -1.2; X[2]:= 1; AGAIN:= "TRUE";     
     F:= RNK1MIN(2, X, G, H, ROSENBROCK, IN, OUT);        
     "GOTO" PRINT;
 NEXT: X[1]:= -1.2; X[2]:= 1; AGAIN:= "FALSE";  
     F:= FLEMIN(2, X, G, H, ROSENBROCK, IN, OUT);         
 PRINT: OUTPUT(61, "(""("LEAST VALUE:")"B+.15D"+3D,//, "("X:")",    
     2(B+.15D"+3DB),//,"("GRADIENT:")", 2(B+.15D"+3DB),//, "("METRIC:")"      
     ,2(B+.15D"+3DB),/,32B+.15D"+3D,//,"("OUT:")", 5(B+.15D"+3DB,/),///       
     ")",F, X[1], X[2], G[1], G[2], H[1], H[2], H[3], OUT[0], OUT[1],         
     OUT[2], OUT[3], OUT[4]);         
     "IF" AGAIN "THEN" "GOTO" NEXT    
 "END"  
         "EOP"    
        
     DELIVERS:    
        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                     PAGE 9      
        
        
        
     LEAST VALUE: +.200699798801180"-018        
        
     X: +.999999999944840"+000  +.999999999845220"+000    
        
     GRADIENT: +.176731305145950"-007  -.889173179530190"-008       
        
     METRIC: +.499982414863250"+000  +.999957383810230"+000         
                                     +.200489757679290"+001         
        
     OUT: +.164157123774660"-009      
          +.197838933606480"-007      
          +.550000000000000"+002      
          +.800000000000000"+001      
          +.400000000000000"+001      
        
        
        
     LEAST VALUE: +.811973499921290"-016        
        
     X: +.999999999758770"+000  +.999999998616780"+000    
        
     GRADIENT: +.359826657359010"-006  -.180154557938290"-006       
        
     METRIC: +.501085356975550"+000  +.100198139199600"+001         
                                     +.200861655543510"+001         
        
     OUT: +.133802289387830"-008      
          +.402406371833370"-006      
          +.440000000000000"+002      
          +.700000000000000"+001      
          +.000000000000000"+000      
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                    PAGE 10      
        
        
        
 SOURCE TEXT(S):  
0"CODE" 34214;    
     "REAL" "PROCEDURE" RNK1MIN(N, X, G, H, FUNCT, IN, OUT);        
     "VALUE" N;   
     "INTEGER" N; "ARRAY" X, G, H, IN, OUT;     
     "REAL" "PROCEDURE" FUNCT;        
     "BEGIN" "INTEGER" I, IT, N2, CNTL, CNTE, EVL, EVLMAX;
         "BOOLEAN" OK;      
         "REAL" F, F0, FMIN, MU, DG, DG0, GHG, GS, NRMDELTA, ALFA,  
         MACHEPS, RELTOL, ABSTOL, EPS, TOLG, ORTH, AID;   
         "ARRAY" V, DELTA, GAMMA, S, P[1:N];    
         "REAL" "PROCEDURE" VECVEC(L, U, SHIFT, A, B); "CODE" 34010;
         "REAL" "PROCEDURE" MATVEC(L, U, I, A, B); "CODE" 34011;    
         "REAL" "PROCEDURE" TAMVEC(L, U, I, A, B); "CODE" 34012;    
         "PROCEDURE" ELMVEC(L, U, SHIFT, A, B, X); "CODE" 34020;    
         "REAL" "PROCEDURE" SYMMATVEC(L, U, I, A, B); "CODE" 34018; 
         "PROCEDURE" INIVEC(L, U, A, X); "CODE" 31010;    
         "PROCEDURE" INISYMD(LR, UR, SHIFT, A, X); "CODE" 31013;    
         "PROCEDURE" MULVEC(L, U, SHIFT, A, B, X); "CODE" 31020;    
         "PROCEDURE" DUPVEC(L, U, SHIFT, A, B); "CODE" 31030;       
         "PROCEDURE" EIGSYM1(A, N, NUMVAL, VAL, VEC, EM); "CODE" 34156;       
         "PROCEDURE" LINEMIN(N, X, D, ND, A, G, F, F0, F1, DFO, DF1,
         E, S, IN); "CODE" 34210;     
         "PROCEDURE" RNK1UPD(H, N, V, C); "CODE" 34211;   
         "PROCEDURE" DAVUPD(H, N, V, W, C1, C2); "CODE" 34212;      
         "PROCEDURE" FLEUPD(H, N, V, W, C1, C2); "CODE" 34213;      
        
         MACHEPS:= IN[0]; RELTOL:= IN[1]; ABSTOL:= IN[2]; 
         MU:= IN[3]; TOLG:= IN[4]; FMIN:= IN[5]; IT := 0; 
         ALFA:= IN[6]; EVLMAX:= IN[7]; ORTH:= IN[8];      
         N2:= N * (N + 1) // 2; CNTL:= CNTE:= 0; "IF" ALFA > 0 "THEN"         
         "BEGIN" INIVEC(1, N2, H, 0); INISYMD(1, N, 0, H, ALFA) "END";        
         F:= FUNCT(N, X, G); EVL:= 1; DG:= SQRT(VECVEC(1, N, 0, G, G));       
         "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"    
         DELTA[I]:= - SYMMATVEC(1, N, I, H, G); 
         NRMDELTA:= SQRT(VECVEC(1, N, 0, DELTA, DELTA));  
         DG0:= VECVEC(1, N, 0, DELTA, G); OK:= DG0 < 0;   
         EPS:= SQRT(VECVEC(1, N, 0, X, X)) * RELTOL + ABSTOL;       
         "FOR" IT:= IT + 1  "WHILE"   
         (NRMDELTA > EPS "OR" DG > TOLG "OR" ^ OK) "AND" EVL < EVLMAX         
         "DO"     
         "BEGIN" "IF" ^OK "THEN"      
             "BEGIN" "ARRAY" VEC[1:N,1:N], TH[1:N2], EM[0:9];       
                 EM[0]:= MACHEPS; EM[2]:= AID:= SQRT(MACHEPS * RELTOL);       
                 EM[4]:= ORTH; EM[6]:= AID * N; EM[8]:= 5;
                 CNTE:= CNTE + 1; DUPVEC(1, N2, 0, TH, H);
                 EIGSYM1(TH,N,N,V,VEC,EM);      
                 "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"      
                 "BEGIN" AID:= - TAMVEC(1, N, I, VEC, G); 
                     S[I]:= AID * ABS(V[I]); V[I]:= AID * SIGN(V[I])
                 "END"      
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                    PAGE 11      
                                                                 ;  
        
        
                 "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"      
                 "BEGIN" DELTA[I]:= MATVEC(1, N, I, VEC, S);        
                     P[I]:= MATVEC(1, N, I, VEC, V)       
                 "END";     
                 DG0:= VECVEC(1, N, 0, DELTA, G);         
                 NRMDELTA:= SQRT(VECVEC(1, N, 0, DELTA, DELTA))     
             "END" CALCULATING GREENSTADTS DIRECTION;     
             DUPVEC(1, N, 0, S, X); DUPVEC(1, N, 0, V, G);
             "IF" IT > N "THEN" ALFA:= 1 "ELSE" 
             "BEGIN" "IF" IT ^= 1 "THEN" ALFA:= ALFA / NRMDELTA "ELSE"        
                 "BEGIN" ALFA:= 2 * (FMIN - F) / DG0;     
                 "IF" ALFA > 1 "THEN" ALFA:= 1  
                 "END"      
             "END";         
             ELMVEC(1, N, 0, X, DELTA, ALFA);   
             F0:= F; F:= FUNCT(N, X, G); EVL:= EVL +1 ;   
             DG:= VECVEC(1, N, 0, DELTA, G);    
             "IF" IT = 1 "OR" F0 - F < -MU * DG0 * ALFA "THEN"      
             "BEGIN" I:= EVLMAX - EVL; CNTL:= CNTL +1 ;   
                 LINEMIN(N, S, DELTA, NRMDELTA, ALFA, G, FUNCT, F0, F,        
                 DG0, DG, I, "FALSE", IN); EVL:= EVL + I; 
                 DUPVEC(1, N, 0, X, S);         
             "END" LINEMINIMIZATION;  
             DUPVEC(1, N, 0, GAMMA, G); ELMVEC(1, N, 0, GAMMA, V, -1);        
             "IF" ^ OK "THEN" MULVEC(1, N, 0, V, P, -1);  
             DG:= DG - DG0; "IF" ALFA ^= 1 "THEN"         
             "BEGIN" MULVEC(1, N, 0, DELTA, DELTA, ALFA); 
                 MULVEC(1, N, 0, V, V, ALFA);   
                 NRMDELTA:= NRMDELTA * ALFA; DG:= DG * ALFA         
             "END";         
             DUPVEC(1, N, 0, P, GAMMA); ELMVEC(1, N, 0, P, V, 1);   
             "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"
             V[I]:= SYMMATVEC(1, N, I, H, GAMMA);         
             DUPVEC(1, N, 0, S, DELTA); ELMVEC(1, N, 0, S, V, -1);  
             GS:= VECVEC(1, N, 0, GAMMA, S);    
             GHG:= VECVEC(1, N, 0, V, GAMMA);   
             AID:= DG / GS; 
             "IF" VECVEC(1, N, 0, DELTA, P) ** 2 > VECVEC(1, N, 0, P, P)      
             * (ORTH * NRMDELTA) ** 2 "THEN" RNK1UPD(H, N, S, 1 / GS)         
             "ELSE" "IF" AID >= 0 "THEN"        
             FLEUPD(H, N, DELTA, V, 1 / DG, (1 + GHG / DG) / DG) "ELSE"       
             DAVUPD(H, N, DELTA, V, 1 / DG, 1 / GHG);     
             "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"
             DELTA[I]:= -SYMMATVEC(1, N, I, H, G);        
             ALFA:= NRMDELTA;         
             NRMDELTA:= SQRT(VECVEC(1, N, 0, DELTA, DELTA));        
             EPS:= SQRT(VECVEC(1, N, 0, X, X)) * RELTOL + ABSTOL;   
             DG:= SQRT(VECVEC(1, N, 0, G, G));  
             DG0:= VECVEC(1, N, 0, DELTA, G); OK:= DG0 <= 0         
         "END" ITERATION;   
         OUT[0]:= NRMDELTA; OUT[1]:= DG; OUT[2]:= EVL;    
         OUT[3]:= CNTL; OUT[4]:= CNTE; RNK1MIN:= F        
     "END" RNK1MIN;         
         "EOP"    
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                    PAGE 12      
        
        
0"CODE" 34215;    
     "REAL" "PROCEDURE" FLEMIN(N, X, G, H, FUNCT, IN, OUT);         
     "VALUE" N;   
     "INTEGER" N; "ARRAY" X, G, H, IN, OUT;     
     "REAL" "PROCEDURE" FUNCT;        
     "BEGIN" "INTEGER" I, IT, CNTL, EVL, EVLMAX;
         "REAL" F,F0,FMIN,MU,DG,DG0,NRMDELTA,ALFA,RELTOL,ABSTOL,    
         EPS, TOLG, AID;    
         "ARRAY" V, DELTA, S[1:N];    
         "REAL" "PROCEDURE" VECVEC(L, U, SHIFT, A, B); "CODE" 34010;
         "PROCEDURE" ELMVEC(L, U, SHIFT, A, B, X); "CODE" 34020;    
         "REAL" "PROCEDURE" SYMMATVEC(L, U, I, A, B); "CODE" 34018; 
         "PROCEDURE" INIVEC(L, U, A, X); "CODE" 31010;    
         "PROCEDURE" INISYMD(LR, UR, SHIFT, A, X); "CODE" 31013;    
         "PROCEDURE" MULVEC(L, U, SHIFT, A, B, XB); "CODE" 31020;   
         "PROCEDURE" DUPVEC(L, U, SHIFT, A, B); "CODE" 31030;       
         "PROCEDURE" LINEMIN(N, X, D, ND, A, G, F, F0, F1, DF0, DF1,
         E, S, IN); "CODE" 34210;     
         "PROCEDURE" DAVUPD(H, N, V, W, C1, C2); "CODE" 34212;      
         "PROCEDURE" FLEUPD(H, N, V, W, C1, C2); "CODE" 34213;      
        
         RELTOL:= IN[1]; ABSTOL:= IN[2]; MU:= IN[3];      
         TOLG:= IN[4]; FMIN:= IN[5]; ALFA:= IN[6];        
         EVLMAX:= IN[7]; OUT[4]:= 0; IT := 0;   
         F:= FUNCT(N, X, G); EVL:= 1; CNTL:= 0;"IF" ALFA > 0 "THEN" 
         "BEGIN" INIVEC(1, N * (N + 1) // 2, H, 0);       
             INISYMD(1, N, 0, H, ALFA)
         "END";   
         "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"    
         DELTA[I]:= - SYMMATVEC(1, N, I, H, G); 
         DG:= SQRT(VECVEC(1, N, 0, G, G));      
         NRMDELTA:= SQRT(VECVEC(1, N, 0, DELTA, DELTA));  
         EPS:= SQRT(VECVEC(1, N, 0, X, X)) * RELTOL + ABSTOL;       
         DG0:= VECVEC(1, N, 0, DELTA, G);"COMMENT"        
1SECTION : 5.1.2.2.3          (DECEMBER 1975)                    PAGE 13      
                                                                 ;  
        
        
         "FOR" IT := IT +1  "WHILE"   
         (NRMDELTA > EPS "OR" DG > TOLG ) "AND" EVL < EVLMAX "DO"   
         "BEGIN" DUPVEC(1, N, 0, S, X); DUPVEC(1, N, 0, V, G);      
             "IF" IT >= N "THEN" ALFA:= 1 "ELSE"
             "BEGIN" "IF" IT ^= 1 "THEN" ALFA:= ALFA / NRMDELTA "ELSE"        
                 "BEGIN" ALFA:= 2 * (FMIN - F) / DG0;     
                     "IF" ALFA > 1 "THEN" ALFA:= 1        
                 "END"      
             "END";         
             ELMVEC(1, N, 0, X, DELTA, ALFA);   
             F0:= F; F:= FUNCT(N, X, G); EVL:= EVL +1 ;   
             DG:= VECVEC(1, N, 0, DELTA, G);    
             "IF" IT = 1 "OR" F0 - F < - MU * DG0 * ALFA "THEN"     
             "BEGIN" I:= EVLMAX - EVL; CNTL:= CNTL +1 ;   
                 LINEMIN(N, S, DELTA, NRMDELTA, ALFA, G, FUNCT, F0, F,        
                 DG0, DG, I, "FALSE", IN); EVL:= EVL + I; 
                 DUPVEC(1, N, 0, X, S);         
             "END" LINEMINIMIZATION;  
             "IF" ALFA ^= 1 "THEN" MULVEC(1, N, 0, DELTA, DELTA, ALFA);       
             MULVEC(1, N, 0, V, V, -1); ELMVEC(1, N, 0, V, G, 1);   
             "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"
             S[I]:= SYMMATVEC(1, N, I, H, V);   
             AID:= VECVEC(1, N, 0, V, S); DG:= (DG - DG0) * ALFA;   
             "IF" DG > 0 "THEN"       
             "BEGIN" "IF" DG >= AID "THEN"      
                 FLEUPD(H, N, DELTA, S, 1 / DG, (1 + AID / DG) / DG)
                 "ELSE" DAVUPD(H, N, DELTA, S, 1 / DG, 1 / AID)     
             "END" UPDATING;
             "FOR" I:= 1 "STEP" 1 "UNTIL" N "DO"
             DELTA[I]:= -SYMMATVEC(1, N, I, H, G);        
             ALFA:= NRMDELTA * ALFA;  
             NRMDELTA:= SQRT(VECVEC(1, N, 0, DELTA, DELTA));        
             EPS:= SQRT(VECVEC(1, N, 0, X, X)) * RELTOL + ABSTOL;   
             DG:= SQRT(VECVEC(1, N, 0, G, G));  
             DG0:= VECVEC(1, N, 0, DELTA, G); "IF" DG0 > 0 "THEN"   
             "BEGIN" OUT[4]:= -1 ; "GOTO" EXIT "END"      
         "END" ITERATION;   
     EXIT: OUT[0]:= NRMDELTA; OUT[1]:= DG; OUT[2]:= EVL;  
         OUT[3]:= CNTL; FLEMIN:= F    
     "END" FLEMIN;
         "EOP"