F003: Elementary Matrix Processing

Author(s): H. Lipps	Library: KERNLIB
Submitter:	Submitted: 18.12.1979
Language: Fortran or Assembler or COMPASS	Revised: 15.11.1995

These subprograms perform elementary matrix operations.

Structure:

SUBROUTINE and FUNCTION subprograms
User Entry Names:

RMADD, RMBIL, RMCPY, RMDMP, RMMNA, RMMNS, RMMPA, RMMPS,

RMMPY, RMRAN, RMSCL, RMSET, RMSUB, RMUTL, RUMNA, RUMNS,

RUMPA, RUMPS, RUMPY,

DMADD, DMBIL, DMCPY, DMDMP, DMMNA, DMMNS, DMMPA, DMMPS,

DMMPY, DMRAN, DMSCL, DMSET, DMSUB, DMUTL, DUMNA, DUMNS,

DUMPA, DUMPS, DUMPY,

CMADD, CMBIL, CMCPY, CMDMP, CMMNA, CMMNS, CMMPA, CMMPS,

CMMPY, CMRAN, CMSCL, CMSET, CMSUB, CMUTL, CUMNA, CUMNS,

CUMPA, CUMPS, CUMPY, CMMPYC, CCMMPY, CUMPYC, CCUMPY

External References: LOCF, RANF, DRANF (some Fortran versions only).

Usage:

For t = R (type REAL), t = D (type DOUBLE PRECISION), t = C (type COMPLEX):

CALL tMSET (M,N,S,Z11,Z12,Z21) z_ij = s

CALL tMRAN (M,N,A,B,Z11,Z12,Z21) z_ij = random (see Note 2)

CALL tMCPY (M,N,X11,X12,X21,Z11,Z12,Z21) z_ij = x_ij

CALL tMUTL (N,X11,X12,X21) x_jk = x_kj (j > k) (see Note 3)

CALL tMSCL (M,N,S,X11,X12,X21,Z11,Z12,Z21) z_ij = sx_ij

CALL tMDMP (M,N,D1,D2,X11,X12,X21,Z11,Z12,Z21) z_ij = d_ix_ij

CALL tMADD (M,N,X11,X12,X21,Y11,Y12,Y21,Z11,Z12,Z21) z_ij = x_ij + y_ij

CALL tMSUB (M,N,X11,X12,X21,Y11,Y12,Y21,Z11,Z12,Z21) z_ij = x_ij - y_ij

$$\cdots$$ CALL tMMPY (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tMMPA (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tMMPS (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tMMNA (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tMMNS (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tUMPY (N,U11,U12,U22,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tUMPA (N,U11,U12,U22,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tUMPS (N,U11,U12,U22,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tUMNA (N,U11,U12,U22,Y1,Y2,Z1,Z2)

$$\cdots$$ CALL tUMNS (N,U11,U12,U22,Y1,Y2,Z1,Z2)

$$\sum_{k,j = 1}^{n}$$ F = tMBIL (N,V1,V2,X11,X12,X21,Y1,Y2)

$$\bar{y}_{i}^{} \cdots \bar{y}_{n}^{}$$ CALL CMMPYC(M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\bar{x}_{i1}^{} \cdots \bar{x}_{in}^{}$$ CALL CCMMPY(M,N,X11,X12,X21,Y1,Y2,Z1,Z2)

$$\bar{y}_{j}^{} \cdots \bar{y}_{n}^{}$$ CALL CUMPYC(N,U11,U12,U22,Y1,Y2,Z1,Z2)

$$\bar{u}_{jj}^{} \cdots \bar{u}_{jn}^{}$$ CALL CCUMPY(N,U11,U12,U22,Y1,Y2,Z1,Z2)

where $\bar{x}_{ij}^{}$,$\bar{u}_{jk}^{}$,$\bar{y}_{j}^{}$ are the complex conjugates of x_ij,u_jk,y_j , respectively.

M,N

(INTEGER) The mathematical dimensions of the matrices and vectors (i = 1,2,...,M ; j,k = 1,2,...,N ) .

S,A,B

(Type according to t) The scalar values s , a , and b , respectively.

X11,X12,X21

(Type according to t) Array elements. They must contain the elements x₁₁,x₁₂,x₂₁ of the matrix (x_ij) .

Y11,Y12,Y21

(Type according to t) Array elements. They must contain the elements y₁₁,y₁₂,y₂₁ of the matrix (y_ij) .

Y1,Y2

(Type according to t) Array elements. They must contain the elements y₁,y₂ of the vector (y_j) .

D1,D2

(Type according to t) Array elements. They must contain the elements d₁,d₂ of the vector (d_i) .

V1,V2

(Type according to t) Array elements. They must contain the elements v₁,v₂ of the vector (v_k) .

U11,U12,U22

(Type according to t) Array elements. They must contain the elements u₁₁,u₁₂,u₂₂ of the upper-triangular matrix (u_jk) .

Z11,Z12,Z21

(Type according to t) Array elements. On exit, they will contain the elements z₁₁,z₁₂,z₂₁ of the result matrix (z_ij) .

Z1,Z2

(Type according to t) Array elements. On exit, they will contain the elements z₁,z₂ of the result vector (z_j) .

For M < 1 or N < 1 all subroutines return control without action and all functions assume the value zero.

Accuracy:

On computers with IBM 370 architecture, all routines that accumulate the inner product of type REAL or COMPLEX use double-precision arithmetic internally; the final result is then rounded to single precision.

Notes:

1.

The vectors (y_j) etc. need not be packed: any equidistant spacing of their elements is permitted. The subprograms determine the location of the vector element y_j from the actual arguments Y1 and Y2.
Similarly, the matrices (x_ij) etc. need not be stored according to the Fortran convention; any equidistant spacing of their rows and columns is permitted. In particular, matrices may be stored row-wise. The subprograms determine the location of the matrix element x_ij from the actual arguments X11, X12, and X21.

2.

tMRAN sets z_ij to a random value of type t that is uniformly distributed in the interval (A,B). For CMRAN, the real and imaginary parts of z_ij are distributed uniformly and independently in (REAL(A),REAL(B)) and in (AIMAG(A),AIMAG(B)).

3.

tMUTL copies the upper triangle of the square matrix (x_jk) of order N to the lower triangle of this matrix, thus creating a symmetric matrix.

4.

The use of in-line DO loops will be more efficient than calling the equivalent matrix processing subprogram when the matrix dimensions are sufficiently small, due to the overhead of the subprogram call.

$\bullet$