F003 Elementary Matrix Processing

These subprograms perform elementary matrix operations.

Structure:

SUBROUTINE and FUNCTION subprograms
User Entry Names:

RMADD,	RMBIL,	RMCPY,	RMMNA,	RMMNS,	RMMPA,	RMMPS,	RMMPY,
RMRAN,	RMSCL,	RMSET,	RMSUB,	RMUTL,	RRSCL,	RUMNA,	RUMNS,
RUMPA,	RUMPS,	RUMPY,
DMADD,	DMBIL,	DMCPY,	DMMNA,	DMMNS,	DMMPA,	DMMPS,	DMMPY,
DMRAN,	DMSCL,	DMSET,	DMSUB,	DMUTL,	DRSCL,	DUMNA,	DUMNS,
DUMPA,	DUMPS,	DUMPY,
CMADD,	CMBIL,	CMCPY,	CMMNA,	CMMNS,	CMMPA,	CMMPS,	CMMPY,
CMRAN,	CMSCL,	CMSET,	CMSUB,	CMUTL,	CRSCL,	CUMNA,	CUMNS,
CUMPA,	CUMPS,	CUMPY,	CMMPYC,	CCMMPY,	CUMPYC,	CCUMPY

External References: LOCF (N100), RANF, DRANF (G900) (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 Note2)
CALL tMCPY (M,N,X11,X12,X21,Z11,Z12,Z21)	$z$ij=xij
CALL tMUTL (N,X11,X12,X21)	$x$jk= xkj (j>k) (see Note3)
CALL tMSCL (M,N,S,X11,X12,X21,Z11,Z12,Z21)	$z$ij=sxij
CALL tRSCL (M,N,D1,D2,X11,X12,X21,Z11,Z12,Z21)	$z$ij=dixij
CALL tMADD (M,N,X11,X12,X21,Y11,Y12,Y21,Z11,Z12)	$z$ij=xij+yij
CALL tMSUB (M,N,X11,X12,X21,Y11,Y12,Y21,Z11,Z12)	$z$ij=xij-yij
CALL tMMPY (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=xi1y1+...+xinyn
CALL tMMPA (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=xi1y1+...+xinyn+zi
CALL tMMPS (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=xi1y1+...+xinyn-zi
CALL tMMNA (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=-xi1y1-...-xinyn+zi
CALL tMMNS (M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=-xi1y1-...-xinyn-zi
CALL tUMPY (N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=ujjyj+...+ujnyn
CALL tUMPA (N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=ujjyj+...+ujnyn+zj
CALL tUMPS (N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=ujjyj+...+ujnyn-zj
CALL tUMNA (N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=-ujjyj-...-ujnyn+zj
CALL tUMNS (N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=-ujjyj-...-ujnyn-zj
F = tMBIL (N,V1,V2,X11,X12,X21,Y1,Y2)	$f\; =\; \sum$k,j = 1nvkxkjyj
CALL CMMPYC(M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=xi1yi+...+xinyn
CALL CCMMPY(M,N,X11,X12,X21,Y1,Y2,Z1,Z2)	$z$i=xi1yi+...+xinyn
CALL CUMPYC(N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=ujjyj+...+ujnyn
CALL CCUMPY(N,U11,U12,U22,Y1,Y2,Z1,Z2)	$z$j=ujjyj+...+ujnyn

where $x$_ij, u_jk, 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) .

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.

F004

H. Lipps