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;