NUMAL Section 1.5.2

BEGIN SECTION : 1.5.2 (January, 1976)

AUTHORS: J. WOLLESWINKEL AND D. WINTER.

CONTRIBUTOR: J. C. P. BUS.

INSTITUTE: MATHEMATICAL CENTRE.

RECEIVED: 750501.

BRIEF DESCRIPTION:

    THIS SECTION CONTAINS FOURTEEN PROCEDURES FOR CALCULATING,  WITH
    DOUBLE LENGTH ARITHMETIC, THE (SCALAR) PRODUCTS OF SINGLE LENGTH
    VECTORS AND MATRICES.

    LNGVECVEC:  CALCULATES  THE SCALAR PRODUCT OF TWO VECTORS  GIVEN IN
                ONE-DIMENSIONAL ARRAYS;
    LNGMATVEC:  CALCULATES  THE SCALAR PRODUCT OF A VECTOR  GIVEN  IN A
                ONE-DIMENSIONAL ARRAY AND A ROW OF A MATRIX  GIVEN IN A
                TWO DIMENSIONAL ARRAY;
    LNGTAMVEC:  CALCULATES  THE SCALAR PRODUCT OF A VECTOR  GIVEN  IN A
                ONE-DIMENSIONAL ARRAY AND A COLUMN OF A MATRIX GIVEN IN
                A  TWO-DIMENSIONAL ARRAY;
    LNGMATMAT:  CALCULATES THE SCALAR PRODUCT OF A ROW OF A MATRIX  AND
                A COLUMN OF ANOTHER MATRIX,  WHICH  ARE  BOTH  GIVEN IN
                TWO-DIMENSIONAL ARRAYS;
    LNGTAMMAT:  CALCULATES  THE SCALAR PRODUCT  OF COLUMNS OF MATRICES,
                WHICH  ARE  BOTH  GIVEN IN TWO-DIMENSIONAL ARRAYS;
    LNGMATTAM:  CALCULATES  THE  SCALAR  PRODUCT  OF ROWS  OF MATRICES,
                WHICH  ARE  BOTH  GIVEN IN TWO-DIMENSIONAL ARRAYS;
    LNGSEQVEC:  CALCULATES THE SCALAR PRODUCT  OF TWO VECTORS  GIVEN IN
                ONE-DIMENSIONAL  ARRAYS,   WHERE  THE  MUTUAL  SPACINGS
                BETWEEN   THE  INDICES  OF  THE  FIRST  VECTOR   CHANGE
                LINEARLY;
    LNGSCAPRD1: CALCULATES  THE SCALAR PRODUCT OF TWO VECTORS  GIVEN IN
                ONE-DIMENSIONAL  ARRAYS,  WHERE  THE SPACINGS  OF  BOTH
                VECTORS ARE CONSTANT;
    LNGSYMMATVEC: CALCULATES  THE SCALAR PRODUCT OF A VECTOR GIVEN IN A
                ONE-DIMENSIONAL ARRAY  AND A ROW OF A SYMMETRIC MATRIX,
                WHOSE  UPPER TRIANGLE  IS STORED  COLUMN-WISE IN A ONE-
                DIMENSIONAL ARRAY;
    THE ABOVE PROCEDURES HAVE THE POSSIBILITY OF ADDING A DOUBLE LENGTH
    SCALAR TO THE CALCULATED SCALAR PRODUCT;

    LNGFULMATVEC: CALCULATES THE VECTOR A * B, WHERE A IS A GIVEN
                MATRIX AND B IS A VECTOR;
    LNGFULTAMVEC: CALCULATES THE VECTOR A' * B, WHERE A' IS THE
                TRANSPOSED OF THE MATRIX A AND B IS A VECTOR;
    LNGFULSYMMATVEC: 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;
    LNGRESVEC:  CALCULATES THE RESIDUAL VECTOR A * B + X * C, WHERE A
                IS A GIVEN MATRIX, B AND C ARE VECTORS AND X IS A
                SCALAR;
    LNGSYMRESVEC: CALCULATES THE RESIDUAL VECTOR A * B + X * C, WHERE A
                IS A SYMMETRIC MATRIX, WHOSE UPPERTRIANGLE IS STORED
                COLUMNWISE IN A ONE-DIMENSIONAL ARRAY, B AND C ARE
                VECTORS AND, X IS A SCALAR.
    IN THIS SECTION (X, XX) DENOTES A DOUBLE-LENGTH NUMBER WITH HEAD X
    AND TAIL XX (SEE METHOD AND PERFORMANCE).

KEYWORDS:

    ELEMENTARY OPERATIONS,
    VECTOR OPERATIONS,
    SCALAR PRODUCTS,
    DOUBLE-LENGTH ARITHMETIC.


SUBSECTION: LNGVECVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGVECVEC(L, U, SHIFT, A, B, C, CC, D, DD);
    "VALUE" L, U, SHIFT, C, CC; "INTEGER" L, U, SHIFT;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34410;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    SHIFT:  <ARITHMETIC EXPRESSION>;
            THE INDEX-SHIFTING PARAMETER OF THE VECTOR GIVEN IN B;
    A:      <ARRAY IDENTIFIER>;
            ONE OF THE VECTORS SHOULD BE GIVEN IN ARRAY A[L:U];
    B:      <ARRAY IDENTIFIER>;
            THE   OTHER   VECTOR    SHOULD    BE    GIVEN    IN   ARRAY
            B[L + SHIFT : U + SHIFT];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS  A[L:U]  AND  B[L + SHIFT : U + SHIFT].

LANGUAGE:   COMPASS.


SUBSECTION: LNGMATVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGMATVEC(L, U, I, A, B, C, CC, D, DD);
    "VALUE" L, U, I, C, CC; "INTEGER" L, U, I;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34411;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    I:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE ROW-VECTOR GIVEN IN ARRAY A;
    A:      <ARRAY IDENTIFIER>;
            THE ROW-VECTOR SHOULD BE GIVEN IN ARRAY A[I:I, L:U];
    B:      <ARRAY IDENTIFIER>;
            THE VECTOR SHOULD BE GIVEN IN ARRAY B[L:U];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS  A[I:I, L:U]  AND  B[L:U].

LANGUAGE:   COMPASS.


SUBSECTION: LNGTAMVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGTAMVEC(L, U, I, A, B, C, CC, D, DD);
    "VALUE" L, U, I, C, CC; "INTEGER" L, U, I;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34412;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    I:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE COLUMN-VECTOR GIVEN IN ARRAY A;
    A:      <ARRAY IDENTIFIER>;
            THE COLUMN-VECTOR SHOULD BE GIVEN IN ARRAY A[L:U, I:I];
    B:      <ARRAY IDENTIFIER>;
            THE VECTOR SHOULD BE GIVEN IN ARRAY B[L:U];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS  A[L:U, I:I]  AND  B[L:U].

LANGUAGE:   COMPASS.


SUBSECTION: LNGMATMAT.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGMATMAT(L, U, I, J, A, B, C, CC, D, DD);
    "VALUE" L, U, I, J, C, CC; "INTEGER" L, U, I, J;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34413;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    I:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE ROW-VECTOR GIVEN IN ARRAY A;
    J:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE COLUMN-VECTOR GIVEN IN ARRAY B;
    A:      <ARRAY IDENTIFIER>;
            THE ROW-VECTOR SHOULD BE GIVEN IN ARRAY A[I:I, L:U];
    B:      <ARRAY IDENTIFIER>;
            THE COLUMN-VECTOR SHOULD BE GIVEN IN ARRAY B[L:U, J:J];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS  A[I:I, L:U]  AND  B[L:U, J:J].

LANGUAGE:   COMPASS.


SUBSECTION: LNGTAMMAT.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGTAMMAT(L, U, I, J, A, B, C, CC, D, DD);
    "VALUE" L, U, I, J, C, CC; "INTEGER" L, U, I, J;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34414;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    I:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE COLUMN-VECTOR GIVEN IN ARRAY A;
    J:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE COLUMN-VECTOR GIVEN IN ARRAY B;
    A:      <ARRAY IDENTIFIER>;
            ONE  OF  THE  COLUMN-VECTORS   SHOULD  BE  GIVEN  IN  ARRAY
            A[L:U, I:I];
    B:      <ARRAY IDENTIFIER>;
            THE  OTHER  COLUMN-VECTOR   SHOULD   BE   GIVEN   IN  ARRAY
            B[L:U, J:J];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS  A[L:U, I:I]  AND  B[L:U, J:J].

LANGUAGE:   COMPASS.


SUBSECTION: LNGMATTAM.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGMATTAM(L, U, I, J, A, B, C, CC, D, DD);
    "VALUE" L, U, I, J, C, CC; "INTEGER" L, U, I, J;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34415;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    I:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE ROW-VECTOR GIVEN IN ARRAY A;
    J:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE ROW-VECTOR GIVEN IN ARRAY B;
    A:      <ARRAY IDENTIFIER>;
            ONE OF THE ROW-VECTORS SHOULD BE GIVEN IN ARRAY A[I:I,L:U];
    B:      <ARRAY IDENTIFIER>;
            THE OTHER ROW-VECTOR SHOULD BE GIVEN IN ARRAY B[J:J, L:U];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS  A[I:I, L:U]  AND  B[J:J, L:U].

LANGUAGE:   COMPASS.


SUBSECTION: LNGSEQVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGSEQVEC(L, U, IL, SHIFT, A, B, C, CC, D, DD);
    "VALUE" L, U, IL, SHIFT, C, CC; "INTEGER" L, U, IL, SHIFT;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34416;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    IL:     <ARITHMETIC EXPRESSION>;
            THE FIRST INDEX OF THE VECTOR GIVEN IN ARRAY A;
    SHIFT:  <ARITHMETIC EXPRESSION>;
            THE INDEX-SHIFTING PARAMETER OF THE VECTOR GIVEN IN B;
    A:      <ARRAY IDENTIFIER>;
            ONE OF THE VECTORS SHOULD BE GIVEN IN ARRAY  A[P:Q],  WHERE
            P = MIN(IL + (J + L - 1) * (J - 1) // 2; J = L, ..., U) AND
            Q = MAX(IL + (J + L - 1) * (J - 1) // 2; J = L, ..., U);
    B:      <ARRAY IDENTIFIER>;
            THE   OTHER   VECTOR    SHOULD    BE    GIVEN    IN   ARRAY
            B[L + SHIFT : U + SHIFT];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE  ARRAYS   A[P:Q]   (SEE  THE  MEANING  OF  PARAMETER   A )  AND
    B[L + SHIFT: U + SHIFT], WHERE THE ELEMENTS OF THE FIRST VECTOR ARE
    A[IL + (J + L - 1) * (J - 1) // 2], J = L, ..., U.

LANGUAGE:   COMPASS.


SUBSECTION: LNGSCAPRD1.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGSCAPRD1(LA, SA, LB, SB, N, A, B, C, CC, D, DD);
    "VALUE" LA, SA, LB, SB, N, C, CC; "INTEGER" LA, SA, LB, SB, N;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34417;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    LA:     <ARITHMETIC EXPRESSION>;
            THE FIRST INDEX OF THE VECTOR GIVEN IN ARRAY A;
    SA:     <ARITHMETIC EXPRESSION>;
            THE SPACING OF THE VECTOR GIVEN IN ARRAY A;
    LB:     <ARITHMETIC EXPRESSION>;
            THE FIRST INDEX OF THE VECTOR GIVEN IN ARRAY B;
    SB:     <ARITHMETIC EXPRESSION>;
            THE SPACING OF THE VECTOR GIVEN IN ARRAY B;
    N:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT; IF N < 1, THEN ON
            EXIT THE RESULT (D, DD) WILL SATISFY: (D, DD) = (C, CC);
    A:      <ARRAY IDENTIFIER>;
            ONE   OF   THE   VECTORS   SHOULD   BE   GIVEN   IN   ARRAY
            A[MIN(LA, LA + (N - 1) * SA) : MAX(LA, LA + (N - 1) * SA)];
    B:      <ARRAY IDENTIFIER>;
            THE   OTHER   VECTOR    SHOULD    BE    GIVEN    IN   ARRAY
            B[MIN(LB, LB + (N - 1) * SB) : MAX(LB, LB + (N - 1) * SB)];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE ARRAYS A[MIN(LA, LA + (N - 1) * SA):MAX(LA, LA + (N - 1) * SA)]
    AND   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.

LANGUAGE:   COMPASS.


SUBSECTION: LNGSYMMATVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGSYMMATVEC(L, U, I, A, B, C, CC, D, DD);
    "VALUE" L, U, I, C, CC; "INTEGER" L, U, I;
    "REAL" C, CC, D, DD; "ARRAY" A, B;
    "CODE" 34418;

    THE MEANING OF THE FORMAL PARAMETERS IS:
    L:      <ARITHMETIC EXPRESSION>;
            THE LOWER BOUND OF THE RUNNING SUBSCRIPT;
    U:      <ARITHMETIC EXPRESSION>;
            THE UPPER BOUND OF THE RUNNING SUBSCRIPT;
    I:      <ARITHMETIC EXPRESSION>;
            THE INDEX OF THE ROW  OF THE SYMMETRIC MATRIX,  WHOSE UPPER
            TRIANGLE IS STORED COLUMN-WISE IN THE ONE-DIMENSIONAL ARRAY
            A;
    A:      <ARRAY IDENTIFIER>;
            THE ROW OF THE SYMMETRIC MATRIX  SHOULD BE GIVEN  IN  ARRAY
            A[P:Q], WHERE, 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>;
            THE VECTOR SHOULD BE GIVEN IN ARRAY B[L:U];
    C, CC:  <ARITHMETIC EXPRESSION>;
            THE HEAD AND TAIL OF  THE DOUBLE-LENGTH SCALAR  THAT HAS TO
            BE ADDED TO THE CALCULATED SCALAR PRODUCT; IF  CC  IS NOT A
            TAIL TO C THEN AN ERROR MESSAGE WILL BE PRINTED (SEE METHOD
            AND PERFORMANCE);
    D, DD:  <REAL VARIABLE>;
            EXIT:   THE HEAD AND TAIL  OF  THE CALCULATED DOUBLE-LENGTH
                    RESULT.

PROCEDURES USED:
    DPMUL  = CP31103;
    LNGADD = CP31105.

DATA AND RESULTS:

    (D, DD):= (C, CC) + THE SCALAR PRODUCT  OF  THE  VECTORS  GIVEN  IN
    THE ARRAYS  A[P:Q]  (SEE THE MEANING OF PARAMETER  A)  AND  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 VALUES OF  L,  U,  I
    SHOULD BE POSITIVE.

LANGUAGE:   ALGOL 60.


SUBSECTION: LNGFULMATVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGFULMATVEC(LR, UR, LC, UC, A, B, C);
    "VALUE" LR, UR, LC, UC; "INTEGER" LR, UR, LC, UC;
    "ARRAY" A, B, C;
    "CODE" 31505;

    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, CALCULATED WITH DOUBLE LENGTH ARITHMETIC,
            IS DELIVERED IN C.

LANGUAGE:   COMPASS.
    (FOR THE COMPASS-VERSION THE PARAMETER B CAN BE ASSUMED TO HAVE
    BEEN SPECIFIED "VALUE".)

METHOD AND PERFORMANCE:

    ELEMENTARY.


SUBSECTION: LNGFULTAMVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGFULTAMVEC(LR, UR, LC, UC, A, B, C);
    "VALUE" LR, UR, LC, UC; "INTEGER" LR, UR, LC, UC;
    "ARRAY" A, B, C;
    "CODE" 31506;

    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, CALCULATED WITH DOUBLE LENGTH ARITHMETIC,
            IS DELIVERED IN C; HERE A' DENOTES THE TRANSPOSED OF THE
            MATRIX A.

LANGUAGE:   COMPASS.
    (FOR THE COMPASS-VERSION THE PARAMETER B CAN BE ASSUMED TO HAVE
    BEEN SPECIFIED "VALUE".)

METHOD AND PERFORMANCE:

    ELEMENTARY.


SUBSECTION: LNGFULSYMMATVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGFULSYMMATVEC(LR, UR, LC, UC, A, B, C);
    "VALUE" LR, UR, LC, UC, B; "INTEGER" LR, UR, LC, UC;
    "ARRAY" A, B, C;
    "CODE" 31507;

    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, CALCULATED WITH DOUBLE LENGTH ARITHMETIC,
            IS DELIVERED IN C.

PROCEDURES USED:

    LNGSYMMATVEC = CP34418.

LANGUAGE:   ALGOL 60.

METHOD AND PERFORMANCE:

    ELEMENTARY.


SUBSECTION: LNGRESVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGRESVEC(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;
    "CODE" 31508;

    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, CALCULATED WITH DOUBLE LENGTH
            ARITHMETIC, IS OVERWRITTEN ON C.

LANGUAGE:   COMPASS.
    (FOR THE COMPASS-VERSION THE PARAMETER B CAN BE ASSUMED TO HAVE
    BEEN SPECIFIED "VALUE".)

METHOD AND PERFORMANCE:

    ELEMENTARY.


SUBSECTION: LNGSYMRESVEC.

CALLING SEQUENCE:

    THE HEADING OF THE PROCEDURE READS:
    "PROCEDURE" LNGSYMRESVEC(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" 31509;

    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, CALCULATED WITH DOUBLE LENGTH
            ARITHMETIC, IS OVERWRITTEN ON C.

PROCEDURES USED:

    DPMUL        = CP31103;
    LNGSYMMATVEC = CP34418.

LANGUAGE:   ALGOL 60.

METHOD AND PERFORMANCE:

    ELEMENTARY.

METHOD AND PERFORMANCE:

    ALL PROCEDURES GIVEN IN THIS SECTION MAKE USE  OF THE DOUBLE-LENGTH
    ARITHMETIC  OPERATIONS  AVAILABLE  IN HARDWARE  ON  THE CYBER 73.
    LET (X, XX) DENOTE A DOUBLE-LENGTH NUMBER, THEN WE WILL SAY THAT XX
    IS A TAIL TO X, WHEN THE FOLLOWING CONDITIONS HOLD:
                        X = FL1(X + XX),
                  (X, XX) = FL2(X + XX),
    WHERE  FL1(. + .)  AND FL2(. + .) DENOTE SINGLE-LENGTH RESPECTIVELY
    DOUBLE-LENGTH ADDITION WITH TRUNCATING OF THE RESULT TO  48 AND  96
    BITS RESPECTIVELY.
    WHEN A PROCEDURE DELIVERS A DOUBLE LENGTH RESULT IN D AND DD, THEN
    THESE RESULTS ARE SUCH THAT DD IS A TAIL TO D; WHEN ONE SHOULD
    PROVIDE AN INITIALIZING DOUBLE LENGTH SCALAR IN C AND CC, THEN CC
    SHOULD BE A TAIL TO C, OTHERWISE THE FOLLOWING ERROR MESSAGE WILL
    BE PRINTED:
            DP PARAMETER TAIL ERROR
    AND EXECUTION OF THE PROGRAM WILL TERMINATE IN THE USUAL WAY.
    NOTE THAT CC = 0 IS A TAIL TO C FOR ALL VALUES OF C. FURTHERMORE,
    IT SEEMS WORTHWHILE TO NOTE THAT THE ARRAY B MUST BE A VALUE
    PARAMETER IN ALGOL 60, HOWEVER, IN THE COMPASS ROUTINE THE
    DUPLICATION OF THIS ARRAY IS ONLY DONE IF NECESSARY, I.E. IF THE
    ACTUAL PARAMETERS B AND C ARE THE SAME.

SOURCE TEXTS:

    THE PROCEDURES IN THIS SECTION ARE WRITTEN IN COMPASS, EXCEPT FOR
    LNGSYMMATVEC, LNGFULSYMMATVEC AND LNGSYMRESVEC.
    WE GIVE EQUIVALENT ALGOL 60 TEXTS OF THE COMPASS ROUTINES. FOR THE
    COMPASS TEXT SEE APPENDIX C, SECTION 1.5.2.

"CODE" 34410;
"CODE" 34411;

"CODE" 34412;

"CODE" 34413;
"CODE" 34414;

"CODE" 34415;

"CODE" 34416;
"CODE" 34417;

"CODE" 34418;

"CODE" 31505;

"CODE" 31506;
"CODE" 31507;

"CODE" 31508;

"CODE" 31509;