Basic Linear Algebra Subprograms
The basic linear algebra subprograms, normally referred to as the BLAS, are routines for low-level operations such as dot products, matrix times vector, and matrix times matrix. Lawson et al. (1979) published the original set of 38 BLAS. The IMSL BLAS collection includes these 38 subprograms plus additional ones that extend their functionality. Since Dongarra et al. (1988 and 1990) published extensions to this set, it is customary to refer to the original 38 as Level 1 BLAS. The Level 1 operations are performed on one or two vectors of data. An extended set of subprograms perform operations involving a matrix and one or two vectors. These are called the Level 2 BLAS (see
Specification of the Level 2 BLAS). An additional extended set of operations on matrices is called the Level 3 BLAS (see
Specification of the Level 3 BLAS).
Users of the BLAS will often benefit from using versions of the BLAS supplied by hardware vendors, if available. This can provide for more efficient execution of many application programs. The BLAS provided by IMSL are written in FORTRAN. Those supplied by vendors may be written in other languages, such as assembler. The documentation given below for the BLAS is compatible with a vendor’s version of the BLAS that conforms to the published specifications.
Programming Notes for Level 1 BLAS
The Level 1 BLAS do not follow the usual IMSL naming conventions. Instead, the names consist of a prefix of one or more of the letters “I”, “S”, “D”, “C”, and “Z”; a root name; and sometimes a suffix. For subprograms involving a mixture of data types, the output type is indicated by the first prefix letter. The suffix denotes a variant algorithm. The prefix denotes the type of the operation according to the following table:
I | Integer | | |
S | Real | C | Complex |
D | Double | Z | Double Complex |
SD | Single and Double | CZ | Single and Double Complex |
DQ | Double and Quadruple | ZQ | Double and Quadruple Complex |
Vector arguments have an increment parameter that specifies the storage space or stride between elements. The correspondence between the vectors x and y and the arguments SX and SY, and INCX and INCY is
Function subprograms
SXYZ and
DXYZ refer to a third vector argument
z. The storage increment
INCZ for
z is defined like
INCX and
INCY. In the Level 1 BLAS, only positive values of
INCX are allowed for operations that have a single vector argument. The loops in all of the Level 1 BLAS process the vector arguments in order of increasing
i. For
INCX,
INCY,
INCZ < 0, this implies processing in reverse storage order.
The function subprograms in the Level 1 BLAS are all illustrated by means of an assignment statement. For example, see
SDOT. Any value of a function subprogram can be used in an expression or as a parameter passed to a subprogram as long as the data types agree.
Descriptions of the Level 1 BLAS Subprograms
The set of Level 1 BLAS are summarized in
Table 6. This table also lists the page numbers where the subprograms are described in more detail.
Specification of the Level 1 BLAS
With the definitions,
MX = max {1, 1 + (N ‑ 1)|INCX|}
MY = max {1, 1 + (N ‑ 1)|INCY|}
MZ = max {1, 1 + (N ‑ 1)|INCZ|}
the subprogram descriptions assume the following FORTRAN declarations:
IMPLICIT INTEGER (I-N)
IMPLICIT REAL S
IMPLICIT DOUBLE PRECISION D
IMPLICIT COMPLEX C
IMPLICIT DOUBLE COMPLEX Z
INTEGER IX(MX)
REAL SX(MX), SY(MY), SZ(MZ),
SPARAM(5)
DOUBLE PRECISION DX(MX), DY(MY), DZ(MZ),
DPARAM(5)
DOUBLE PRECISION DACC(2), DZACC(4)
COMPLEX CX(MX), CY(MY)
DOUBLE COMPLEX ZX(MX), ZY(MY)
Since FORTRAN 77 does not include the type DOUBLE COMPLEX, subprograms with DOUBLE COMPLEX arguments are not available for all systems. Some systems use the declaration COMPLEX * 16 instead of DOUBLE COMPLEX.
In the following descriptions, the original BLAS are marked with an * in the left column.
Table 6 – Level 1 Basic Linear Algebra Subprograms
Operation | Integer | Real | Double | Complex | DoubleComplex | Pg. |
---|
xi ← a | ISET | SSET | DSET | CSET | ZSET | |
yi ← xi | ICOPY | SCOPY | DCOPY | CCOPY | ZCOPY | |
xi ← axi a ∈ R | | SSCAL | DSCAL | CSCAL CSSCAL | ZSCAL ZDSCAL | |
yi ← axi a ∈ R | | SVCAL | DVCAL | CVCAL CSVCAL | ZVCAL ZDVCAL | |
xi ← xi + a | IADD | SADD | DADD | CADD | ZADD | |
xi ← a ‑ xi | ISUB | SSUB | DSUB | CSUB | ZSUB | |
yi ← axi + yi | | SAXPY | DAXPY | CAXPY | ZAXPY | |
yi ↔ xi | ISWAP | SSWAP | DSWAP | CSWAP | ZSWAP | |
x ⋅ y | | SDOT | DDOT | CDOTU CDOTC | ZDOTU ZDOTC | |
x ⋅ y † | | DSDOT | | CZDOTU CZDOTC | ZQDOTU ZQDOTC | |
a + x ⋅ y † | | SDSDOT | DQDDOT | CZUDOT CZCDOT | ZQUDOT ZQCDOT | |
b + x ⋅ y † ACC + b + x ⋅ y † | | SDDOTI SDDOTA | DQDOTI DQDOTA | CZDOTI CZDOTA | ZQDOTI ZQDOTA | |
zi ← xiyi | | SHPROD | DHPROD | | | |
∑xiyizi | | SXYZ | DXYZ | | | |
∑xi | ISUM | SSUM | DSUM | | | |
∑∣xi∣ | | SASUM | DASUM | SCASUM | DZASUM | |
∥x∥2 | | SNRM2 | DNRM2 | SCNRM2 | DZNRM2 | |
Πxi | | SPRDCT | DPRDCT | | | |
i : xi = minj xj | IIMIN | ISMIN | IDMIN | | | |
i : xi = maxj xj | IIMAX | ISMAX | IDMAX | | | |
i : ∣xi∣ = minj ∣xj∣ | | ISAMIN | IDAMIN | ICAMIN | IZAMIN | |
i : ∣ xi∣ = maxj ∣xj∣ | | ISAMAX | IDAMAX | ICAMAX | IZAMAX | |
Construct Givens rotation | | SROTG | DROTG | CROTG | ZROTG | |
Apply Givens rotation | | SROT | DROT | CROT CSROT | ZROT ZDROT | |
Construct modified Givens transform | | SROTMG | DROTMG | | | |
Apply modified Givens transform | | SROTM | DROTM | CSROTM | ZDROTM | |
†Higher precision accumulation used
Set a Vector to a Constant Value
CALL ISET (N, IA, IX, INCX)
CALL SSET (N, SA, SX, INCX)
CALL DSET (N, DA, DX, INCX)
CALL CSET (N, CA, CX, INCX)
CALL ZSET (N, ZA, ZX, INCX)
These subprograms set xi ← a for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Copy a Vector
CALL ICOPY (N, IX, INCX, IY, INCY)
*CALL SCOPY (N, SX, INCX, SY, INCY)
*CALL DCOPY (N, DX, INCX, DY, INCY)
*CALL CCOPY (N, CX, INCX, CY, INCY)
CALL ZCOPY (N, ZX, INCX, ZY, INCY)
These subprograms set yi ← xi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Scale a Vector
*CALL SSCAL (N, SA, SX, INCX)
*CALL DSCAL (N, DA, DX, INCX)
*CALL CSCAL (N, CA, CX, INCX)
CALL ZSCAL (N, ZA, ZX, INCX)
*CALL CSSCAL (N, SA, CX, INCX)
CALL ZDSCAL (N, DA, ZX, INCX)
These subprograms set xi ← axi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately. CAUTION: For CSSCAL and ZDSCAL, the scalar quantity a is real and the vector x is complex.
Multiply a Vector by a Constant
CALL SVCAL (N, SA, SX, INCX, SY, INCY)
CALL DVCAL (N, DA, DX, INCX, DY, INCY)
CALL CVCAL (N, CA, CX, INCX, CY, INCY)
CALL ZVCAL (N, ZA, ZX, INCX, ZY, INCY)
CALL CSVCAL (N, SA, CX, INCX, CY, INCY)
CALL ZDVCAL (N, DA, ZX, INCX, ZY, INCY)
These subprograms set yi ← axi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately. CAUTION: For CSVCAL and ZDVCAL, the scalar quantity a is real and the vector x is complex.
Add a Constant to a Vector
CALL IADD (N, IA, IX, INCX)
CALL SADD (N, SA, SX, INCX)
CALL DADD (N, DA, DX, INCX)
CALL CADD (N, CA, CX, INCX)
CALL ZADD (N, ZA, ZX, INCX)
These subprograms set xi ← xi + a for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Subtract a Vector from a Constant
CALL ISUB (N, IA, IX, INCX)
CALL SSUB (N, SA, SX, INCX)
CALL DSUB (N, DA, DX, INCX)
CALL CSUB (N, CA, CX, INCX)
CALL ZSUB (N, ZA, ZX, INCX)
These subprograms set xi ← a ‑ xi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Constant Times a Vector Plus a Vector
*CALL SAXPY (N, SA, SX, INCX, SY, INCY)
*CALL DAXPY (N, DA, DX, INCX, DY, INCY)
*CALL CAXPY (N, CA, CX, INCX, CY, INCY)
CALL ZAXPY (N, ZA, ZX, INCX, ZY, INCY)
These subprograms set yi ← axi + yi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Swap Two Vectors
CALL ISWAP (N, IX, INCX, IY, INCY)
*CALL SSWAP (N, SX, INCX, SY, INCY)
*CALL DSWAP (N, DX, INCX, DY, INCY)
*CALL CSWAP (N, CX, INCX, CY, INCY)
CALL ZSWAP (N, ZX, INCX, ZY, INCY)
These subprograms perform the exchange yi ↔ xi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Dot Product
*SW = SDOT (N, SX, INCX, SY, INCY)
*DW = DDOT (N, DX, INCX, DY, INCY)
*CW = CDOTU (N, CX, INCX, CY, INCY)
*CW = CDOTC (N, CX, INCX, CY, INCY)
ZW = ZDOTU (N, ZX, INCX, ZY, INCY)
ZW = ZDOTC (N, ZX, INCX, ZY, INCY)
The function subprograms SDOT, DDOT, CDOTU, and ZDOTU compute
The function subprograms CDOTC and ZDOTC compute
The suffix C indicates that the complex conjugates of xi are used. The suffix U indicates that the unconjugated values of xi are used. If N ≤ 0, then the subprograms return zero.
Dot Product with Higher Precision Accumulation
*DW = DSDOT (N, SX, INCX, SY, INCY)
CW = CZDOTC (N, CX, INCX, CY, INCY)
CW = CZDOTU (N, CX, INCX, CY, INCY)
ZW = ZQDOTC (N, ZX, INCX, ZY, INCY)
ZW = ZQDOTU (N, ZX, INCX, ZY, INCY)
The function subprogram DSDOT computes
using double precision accumulation. The function subprograms CZDOTU and ZQDOTU compute
using double and quadruple complex accumulation, respectively. The function subprograms CZDOTC and ZQDOTC compute
using double and quadruple complex accumulation, respectively. If N ≤ 0, then the subprograms return zero.
Constant Plus Dot Product with Higher Precision Accumulation
*SW = SDSDOT (N, SA, SX, INCX, SY, INCY)
DW = DQDDOT (N, DA, DX, INCX, DY, INCY)
CW = CZCDOT (N, CA, CX, INCX, CY, INCY)
CW = CZUDOT (N, CA, CX, INCX, CY, INCY)
ZW = ZQCDOT (N, ZA, ZX, INCX, ZY, INCY)
ZW = ZQUDOT (N, ZA, ZX, INCX, ZY, INCY)
The function subprograms SDSDOT, DQDDOT, CZUDOT, and ZQUDOT compute
using higher precision accumulation where SDSDOT uses double precision accumulation, DQDDOT uses quadruple precision accumulation, CZUDOT uses double complex accumulation, and ZQUDOT uses quadruple complex accumulation. The function subprograms CZCDOT and ZQCDOT compute
using double complex and quadruple complex accumulation, respectively. If N ≤ 0, then the subprograms return zero.
Dot Product Using the Accumulator
SW = SDDOTI (N, SB, DACC, SX, INCX, SY, INCY)
SW = SDDOTA (N, SB, DACC, SX, INCX, SY, INCY)
CW = CZDOTI (N, CB, DACC, CX, INCX, CY, INCY)
CW = CZDOTA (N, CB, DACC, CX, INCX, CY, INCY)
*DW = DQDOTI (N, DB, DACC, DX, INCX, DY, INCY)
*DW = DQDOTA (N, DB, DACC, DX, INCX, DY, INCY)
ZW = ZQDOTI (N, ZB, DZACC, ZX, INCX, ZY, INCY)
ZW = ZQDOTA (N, ZB, DZACC, ZX, INCX, ZY, INCY)
The variable DACC, a double precision array of length two, is used as a quadruple precision accumulator. DZACC, a double precision array of length four, is its complex analog. The function subprograms with a name ending in I initialize DACC to zero. All of the function subprograms then compute
and store the result in DACC. The result, converted to the precision of the function, is also returned as the function value. If N ≤ 0, then the function subprograms return zero.
Hadamard Product
CALL SHPROD (N, SX, INCX, SY, INCY, SZ, INCZ)
CALL DHPROD (N, DX, INCX, DY, INCY, DZ, INCZ)
These subprograms set zi ← xiyi for i = 1, 2, …, N. If N ≤ 0, then the subprograms return immediately.
Triple Inner Product
SW = SXYZ (N, SX, INCX, SY, INCY, SZ, INCZ)
DW = DXYZ (N, DX, INCX, DY, INCY, DZ, INCZ)
These function subprograms compute
If N ≤ 0 then the subprograms return zero.
Sum of the Elements of a Vector
IW = ISUM (N, IX, INCX)
SW = SSUM (N, SX, INCX)
DW = DSUM (N, DX, INCX)
These function subprograms compute
If N ≤ 0, then the subprograms return zero.
Sum of the Absolute Values of the Elements of a Vector
*SW = SASUM (N, SX, INCX)
*DW = DASUM (N, DX, INCX)
*SW = SCASUM (N, CX, INCX)
DW = DZASUM (N, ZX, INCX)
The function subprograms SASUM and DASUM compute
The function subprograms SCASUM and DZASUM compute
If N ≤ 0, then the subprograms return zero. CAUTION: For SCASUM and DZASUM, the function subprogram returns a real value.
Euclidean or ℓ2 Norm of a Vector
*SW = SNRM2 (N, SX, INCX)
*DW = DNRM2 (N, DX, INCX)
*SW = SCNRM2 (N, CX, INCX)
DW = DZNRM2 (N, ZX, INCX)
These function subprograms compute
If N ≤ 0, then the subprograms return zero. CAUTION: For SCNRM2 and DZNRM2, the function subprogram returns a real value.
Product of the Elements of a Vector
SW = SPRDCT (N, SX, INCX)
DW = DPRDCT (N, DX, INCX)
These function subprograms compute
If N ≤ 0, then the subprograms return zero.
Index of Element Having Minimum Value
IW = IIMIN (N, IX, INCX)
IW = ISMIN (N, SX, INCX)
IW = IDMIN (N, DX, INCX)
These function subprograms compute the smallest index i such that xi = min1 ≤ j ≤ Nxj. If N ≤ 0, then the subprograms return zero.
Index of Element Having Maximum Value
IW = IIMAX (N, IX, INCX)
IW = ISMAX (N, SX, INCX)
IW = IDMAX (N, DX, INCX)
These function subprograms compute the smallest index i such that xi = max1 ≤ j ≤ Nxj. If N ≤ 0, then the subprograms return zero.
Index of Element Having Minimum Absolute Value
IW = ISAMIN (N, SX, INCX)
IW = IDAMIN (N, DX, INCX)
IW = ICAMIN (N, CX, INCX)
IW = IZAMIN (N, ZX, INCX)
The function subprograms ISAMIN and IDAMIN compute the smallest index i such that ∣xi∣ = min1 ≤ j ≤ N∣xj∣. The function subprograms ICAMIN and IZAMIN compute the smallest index i such that
If N ≤ 0, then the subprograms return zero.
Index of Element Having Maximum Absolute Value
*IW = ISAMAX (N, SX, INCX)
*IW = IDAMAX (N, DX, INCX)
*IW = ICAMAX (N, CX, INCX)
IW = IZAMAX (N, ZX, INCX)
The function subprograms ISAMAX and IDAMAX compute the smallest index i such that
∣xi∣ = max1 ≤ j≤N∣xj∣. The function subprograms ICAMAX and IZAMAX compute the smallest index i such that
If N ≤ 0, then the subprograms return zero.
Construct a Givens Plane Rotation
*CALL SROTG (SA, SB, SC, SS)
*CALL DROTG (SA, SB, SC, SS)
Given the values a and b, these subprograms compute
and
where r = σ(a2 + b2)1/2 and
Then, the values c, s and r satisfy the matrix equation
The introduction of σ is not essential to the computation of the Givens rotation matrix; but its use permits later stable reconstruction of c and s from just one stored number, an idea due to Stewart (1976). For this purpose, the subprogram also computes
In addition to returning c and s, the subprograms return r overwriting a, and z overwriting b.
Reconstruction of c and s from z can be done as follows:
If z = 1, then set c = 0 and s = 1
If ∣z∣ < 1, then set
If ∣z∣ > 1, then set
Apply a Plane Rotation
*CALL SROT (N, SX, INCX, SY, INCY, SC, SS)
*CALL DROT (N, DX, INCX, DY, INCY, DC, DS)
CALL CSROT (N, CX, INCX, CY, INCY, SC, SS)
CALL ZDROT (N, ZX, INCX, ZY, INCY, DC, DS)
These subprograms compute
If N ≤ 0, then the subprograms return immediately. CAUTION: For CSROT and ZDROT, the scalar quantities c and s are real, and x and y are complex.
Construct a Modified Givens Transformation
*CALL SROTMG (SD1, SD2, SX1, SY1, SPARAM)
*CALL DROTMG (DD1, DD2, DX1, DY1, DPARAM)
The input quantities d1, d2, x1 and y1 define a 2-vector [w1, z1]T by the following:
The subprograms determine the modified Givens rotation matrix H that transforms y1, and thus, z1 to zero. They also replace d1, d2 and x1 with
respectively. That is,
A representation of this matrix is stored in the array SPARAM or DPARAM. The form of the matrix H is flagged by PARAM(1).
PARAM(1) = 1. In this case,
and
The elements PARAM(3) and PARAM(4) are not changed.
PARAM(1) = 0. In this case,
and
The elements PARAM(2) and PARAM(5) are not changed.
PARAM(1) = ‑1. In this case, rescaling was done and
PARAM(2) = ‑2. In this case, H = I where I is the identity matrix. The elements PARAM(2), PARAM(3), PARAM(4) and PARAM(5) are not changed.
The values of d1, d2 and x1are changed to represent the effect of the transformation. The quantity y1, which would be zeroed by the transformation, is left unchanged.
The input value of d1 should be nonnegative, but d2 can be negative for the purpose of removing data from a least-squares problem.
See Lawson et al. (1979) for further details.
Apply a Modified Givens Transformation
*CALL SROTM (N, SX, INCX, SY, INCY, SPARAM)
*CALL DROTM (N, DX, INCX, DY, INCY, DPARAM)
CALL CSROTM (N, CX, INCX, CY, INCY, SPARAM)
CALL ZDROTM (N, ZX, INCX, ZY, INCY, DPARAM)
If PARAM(1) = 1.0, then these subprograms compute
If PARAM(1) = 0.0, then the subprograms compute
If PARAM(1) = 1.0, then the subprograms compute
If N ≤ 0 or if PARAM(1) = ‑2.0, then the subprograms return immediately. CAUTION: For CSROTM and ZDROTM, the scalar quantities PARAM(*) are real and x and y are complex.
Programming Notes for Level 2 and Level 3 BLAS
For definitions of the matrix data structures used in the discussion below, see
Reference Material. The Level 2 and Level 3 BLAS, like the Level 1 BLAS, do not follow the IMSL naming conventions. Instead, the names consist of a prefix of one of the letters “
S”, “
D” , “
C” , or “
Z”. Next is a root name denoting the kind of matrix. This is followed by a suffix indicating the type of the operation.
1 The prefix denotes the type of operation according to the following table:
S Real | C Complex |
D Double | Z Double Complex |
The root names for the kind of matrix:
GE General | GB General Band | SP Symmetric Packed |
SY Symmetric | SB Symmetric Band | TP Triangular Packed |
HE Hermitian | HB Hermitian Band | HP Hermitian Packed |
TR Triangular | TB Triangular Band | |
The suffixes for the type of operation:
MV | Matrix-Vector Product | SV | Solve for Vector |
R | Rank-One Update | | |
RU | Rank-One Update, Unconjugated | RC | Rank-One Update, Conjugated |
R2 | Rank-Two Update | | |
MM | Matrix-Multiply | SM | Symmetric Matrix Multiply |
RK | Rank-K Update | R2K | Rank 2K Update |
1IMSL does not support any extended precision versions of the Level 2 BLAS.
The specifications of the operations are provided by subprogram arguments of CHARACTER*1 data type. Both lower and upper case of the letter have the same meaning:
TRANS, TRANSA, TRANSB | 'N' | No Transpose |
| 'T' | Transpose |
| 'C' | Conjugage and Transpose |
UPLO | 'L' | Lower Triangular |
| 'U' | Upper Triangular |
DIAGNL | 'N' | Non-unit Triangular |
| 'U' | Unit Triangular |
SIDE | 'L' | Multiply “A” Matrix on Left side, or |
| 'R' | Right side of the “B” matrix |
Note: See the “Triangular Mode” section in the
Reference Material for definitions of these terms.
Descriptions of the Level 2 and Level 3 BLAS
The subprograms for Level 2 and Level 3 BLAS that perform operations involving the expression βy or βC do not require that the contents of y or C be defined when β = 0. In that case, the expression βy or βC is defined to be zero. Note that for the _GEMV and _GBMV subprograms, the dimensions of the vectors x and y are implied by the specification of the operation. If TRANS = ’N’, the dimension of y is m; if TRANS = ’T’ or = ’C’, the dimension of y is n. The Level 2 and Level 3 BLAS are summarized in Table 9.2. This table also lists the page numbers where the subprograms are described in more detail.
Specification of the Level 2 BLAS
Type and dimension for variables occurring in the subprogram specifications are
INTEGER INCX, INCY, NCODA, NLCA, NUCA, LDA, M, N
CHARACTER*1 DIAGNL, TRANS, UPLO
REAL SALPHA, SBETA, SX(*), SY(*), SA(LDA,*)
DOUBLE PRECISION DALPHA, DBETA, DX(*), DY(*), DA(LDA,*)
COMPLEX CALPHA, CBETA, CX(*), CY(*), CA(LDA,*)
DOUBLE COMPLEX ZALPHA, ZBETA, ZX(*), ZY(*), ZA(LDA,*)
There is a lower bound on the leading dimension LDA. It must be ≥ the number of rows in the matrix that is contained in this array. Vector arguments have an increment parameter that specifies the storage space or stride between elements. The correspondence between the vector x, y and the arguments SX, SY and INCX, INCY is
In the Level 2 BLAS, only nonzero values of INCX, INCY are allowed for operations that have vector arguments. The Level 3 BLAS do not refer to INCX, INCY.
Specification of the Level 3 BLAS
Type and dimension for variables occurring in the subprogram specifications are
INTEGER K, LDA, LDB, LDC, M, N
CHARACTER*1 DIAGNL, TRANS, TRANSA, TRANSB, SIDE, UPLO
REAL SALPHA, SBETA, SA(LDA,*), SB(LDB,*), SC(LDC,*)
DOUBLE PRECISION DALPHA, DBETA, DA(LDA,*), DB(LDB,*), DC(LDC,*)
COMPLEX CALPHA, CBETA, CA(LDA,*), CB(LDB,*), CC(LDC,*)
DOUBLE COMPLEX ZALPHA, ZBETA, ZA(LDA,*), ZB(LDB,*), ZC(LDC,*)
Each of the integers K, M, N must be ≥ 0. It is an error if any of them are < 0. If any of them are = 0, the subprograms return immediately. There are lower bounds on the leading dimensions LDA, LDB, LDC. Each must be ≥ the number of rows in the matrix that is contained in this array.
Table 7 describes the Level 2 and 3 BLAS subprograms.
Table 7 – Level 2 and Level 3 Basic Linear Algebra Subprograms –
Operation | Real | Double | Complex | DoubleComplex | Pg. |
---|
Matrix-Vector Multiply, General | SGEMV | DGEMV | CGEMV | ZGEMV | |
Matrix-Vector Multiply, Banded | SGBMV | DGBMV | CGBMV | ZGBMV | |
Matrix-Vector Multiply, Hermitian | | | CHEMV | ZHEMV | |
Matrix-Vector Multiply, Packed Hermitian | | | CHPMV | ZHPMV | |
Matrix-Vector Multiply, Hermitian and Banded | | | CHBMV | ZHBMV | |
Matrix-Vector Multiply, Symmetric and Real | SSYMV | DSYMV | | | |
Matrix-Vector Multiply, Packed Symmetric and Real | SSPMV | DSPMV | | | |
Matrix-Vector Multiply, Symmetric and Banded | SSBMV | DSBMV | | | |
Matrix-Vector Multiply, Triangular | STRMV | DTRMV | CTRMV | ZTRMV | |
Matrix-Vector Multiply, Packed Triangular | STPMV | DTPMV | CTPMV | ZTPMV | |
Matrix-Vector Multiply,Triangular and Banded | STBMV | DTBMV | CTBMV | ZTBMV | |
Matrix-Vector Solve, Triangular | STRSV | DTRSV | CTRSV | ZTRSV | |
Matrix-Vector Solve, Triangular and Banded | STBSV | DTBSV | CTBSV | ZTBSV | |
Matrix-Vector Solve, Packed Triangular | STPSV | DTPSV | CTPSV | ZTPSV | |
Rank-One Matrix Update, General and Real | SGER | DGER | | | |
Rank-One Matrix Update, General, Complex and Transpose | | | CGERU | ZGERU | |
Rank-One Matrix Update, General, Complex, and Conjugate Transpose | | | CGERC | ZGERC | |
Rank-One Matrix Update, Hermitian and Conjugate Transpose | | | CHER | ZHER | |
Rank-Two Matrix Update, Hermitian and Conjugate Transpose | | | CHER2 | ZHER2 | |
Rank-Two Matrix Update, Packed and Conjugate Transpose | | | CHPR2 | ZHPR2 | |
Rank-One Matrix Update, Symmetric and Real | SSYR | DSYR | | | |
Rank-One Matrix Update, Packed Symmetric and Real | SSPR | DSPR | | | |
Rank-One Matrix Update, Packed Hermitian | | | CHPR | ZHPR | |
Rank-Two Matrix Update, Symmetric and Real | SSYR2 | DSYR2 | | | |
Rank-Two Matrix Update, Packed Symmetric and Real | SSPR2 | DSPR2 | | | |
Matrix--Matrix Multiply, General | SGEMM | DGEMM | CGEMM | ZGEMM | |
Matrix-Matrix Multiply, Symmetric | SSYMM | DSYMM | CSYMM | ZSYMM | |
Matrix-Matrix Multiply, Hermitian | | | CHEMM | ZHEMM | |
Rank - k Update, Symmetric | SSYRK | DSYRK | CSYRK | ZSYRK | |
Rank - k Update, Hermitian | | | CHERK | ZHERK | |
Rank - 2k Update, Symmetric | SSYR2K | DSYR2K | CSYR2K | ZSYR2K | |
Rank - 2k Update, Hermitian | | | CHER2K | ZHER2K | |
Matrix-Matrix Multiply, Triangular | STRMM | DTRMM | CTRMM | ZTRMM | |
Matrix-Matrix solve, Triangular | STRSM | DTRSM | CTRSM | ZTRSM | |
Matrix–Vector Multiply, General
CALL SGEMV (TRANS, M, N, SALPHA, SA, LDA, SX, INCX, SBETA, SY, INCY)
CALL DGEMV (TRANS, M, N, DALPHA, DA, LDA, DX, INCX, DBETA, DY, INCY)
CALL CGEMV (TRANS, M, N, CALPHA, CA, LDA, CX, INCX, CBETA, CY, INCY)
CALL ZGEMV (TRANS, M, N, ZALPHA, ZA, LDA, ZX, INCX, ZBETA, ZY, INCY)
For all data types, A is an M × N matrix. These subprograms set y to one of the expressions: y ← αAx + βy, y ← αATx + βy, or for complex data,
The character flag TRANS determines the operation.
Matrix–Vector Multiply, Banded
CALL SGBMV (TRANS, M, N, NLCA, NUCA SALPHA, SA, LDA, SX, INCX, SBETA, SY, INCY)
CALL DGBMV (TRANS, M, N, NLCA, NUCA DALPHA, DA, LDA, DX, INCX, DBETA, DY, INCY)
CALL CGBMV (TRANS, M, N, NLCA, NUCA CALPHA, CA, LDA, CX, INCX, BETA, CY, INCY)
CALL ZGBMV (TRANS, M, N, NLCA, NUCA ZALPHA, ZA, LDA, ZX, INCX, ZBETA, ZY, INCY)
For all data types, A is an M × N matrix with NLCA lower codiagonals and NUCA upper codiagonals. The matrix is stored in band storage mode. These subprograms set y to one of the expressions: y ← αAx + βy, y ← αATx + βy, or for complex data,
The character flag TRANS determines the operation.
Matrix-Vector Multiply, Hermitian
CALL CHEMV (UPLO, N, CALPHA, CA, LDA, CX, INCX, CBETA, CY, INCY)
CALL ZHEMV (UPLO, N, ZALPHA, ZA, LDA, ZX, INCX, ZBETA, ZY, INCY)
For complex types, A is an N × N matrix. These subprograms set y ← αAx + βy, where A is an Hermitian matrix. The matrix A is either referenced using the upper or lower triangular part. The character flag UPLO determines the part used.
Matrix-Vector Multiply, Packed Hermitian
CALL CHPMV (UPLO, N, CALPHA, CAP, CX, INCX, CBETA, CY, INCY)
CALL ZHPMV (UPLO, N, ZALPHA, ZAP, ZX, INCX, ZBETA, ZY, INCY)
For complex types, A is an N × N matrix. These subprograms set y ← αAx + βy, where A is an Hermitian matrix. The matrix A is either referenced using the packed upper or lower triangular part. The character flag UPLO determines the part used.
Matrix-Vector Multiply, Hermitian and Banded
CALL CHBMV (UPLO, N, NCODA, CALPHA, CA, LDA, CX, INCX, CBETA, CY, INCY)
CALL ZHBMV (UPLO, N, NCODA, ZALPHA, ZA, LDA, ZX, INCX, ZBETA, ZY, INCY)
For all data types, A is an N × N matrix with NCODA codiagonals. The matrix is stored in band Hermitian storage mode. These subprograms set y ← αAx + βy. The matrix A is either referenced using its upper or lower triangular part. The character flag UPLO determines the part used.
Matrix-Vector Multiply, Symmetric and Real
CALL SSYMV (UPLO, N, SALPHA, SA, LDA, SX, INCX, SBETA, SY, INCY)
CALL DSYMV (UPLO, N, DALPHA, DA, LDA, DX, INCX, DBETA, DY, INCY)
For all data types, A is an N × N matrix. These subprograms set y ← αAx + βy, where A is a symmetric matrix. The matrix A is either referenced using the upper or lower triangular part. The character flag UPLO determines the part used.
Matrix-Vector Multiply, Packed Symmetric and Real
CALL SSPMV (UPLO, N, SALPHA, SAP, SX, INCX, SBETA, SY, INCY)
CALL DSPMV (UPLO, N, DALPHA, DAP, DX, INCX, DBETA, DY, INCY)
For all data types,
A is an
N × N matrix. These subprograms set
y ← αAx +
βy, where
A is a
packed triangular matrix. The matrix
A is either referenced using the packed upper or lower triangular part. The character flag
UPLO determines the part used.
Matrix-Vector Multiply, Symmetric and Banded
CALL SSBMV (UPLO, N, NCODA, SALPHA, SA, LDA, SX, INCX, SBETA, SY, INCY)
CALL DSBMV (UPLO, N, NCODA, DALPHA, DA, LDA, DX, INCX, DBETA, DY, INCY)
For all data types, A is an N × N matrix with NCODA codiagonals. The matrix is stored in band symmetric storage mode. These subprograms set y ← αAx + βy. The matrix A is either referenced using its upper or lower triangular part. The character flag UPLO determines the part used.
Matrix-Vector Multiply, Triangular
CALL STRMV (UPLO, TRANS, DIAGNL, N, SA, LDA, SX, INCX)
CALL DTRMV (UPLO, TRANS, DIAGNL, N, DA, LDA, DX, INCX)
CALL CTRMV (UPLO, TRANS, DIAGNL, N, CA, LDA, CX, INCX)
CALL ZTRMV (UPLO, TRANS, DIAGNL, N, ZA, LDA, ZX, INCX)
For all data types, A is an N × N triangular matrix. These subprograms set x to one of the expressions: x ← Ax, x ← ATx, or for complex data,
The matrix A is either referenced using its upper or lower triangular part and is unit or nonunit triangular. The character flags UPLO, TRANS, and DIAGNL determine the part of the matrix used and the operation performed.
Matrix-Vector Multiply, Packed Triangular
CALL STPMV (UPLO, TRANS, DIAGNL, N, SAP, SX, INCX)
CALL DTPMV (UPLO, TRANS, DIAGNL, N, DAP, DX, INCX)
CALL CTPMV (UPLO, TRANS, DIAGNL, N, CAP, CX, INCX)
CALL ZTPMV (UPLO, TRANS, DIAGNL, N, ZAP, ZX, INCX)
For all data types,
A is an
N × N packed triangular matrix. These subprograms set
x to one of the expressions:
x ← Ax,
x ← ATx, or for complex data,
The matrix A is either referenced using the packed upper or lower triangular part and is unit or nonunit triangular. The character flags UPLO, TRANS, and DIAGNL determine the part of the matrix used and the operation performed.
Matrix-Vector Multiply, Triangular and Banded
CALL STBMV (UPLO, TRANS, DIAGNL, N, NCODA, SA, LDA, SX, INCX)
CALL DTBMV (UPLO, TRANS, DIAGNL, N, NCODA, DA, LDA, DX, INCX)
CALL CTBMV (UPLO, TRANS, DIAGNL, N, NCODA, CA, LDA, CX, INCX)
CALL ZTBMV (UPLO, TRANS, DIAGNL, N, NCODA, ZA, LDA, ZX, INCX)
For all data types, A is an N × N matrix with NCODA codiagonals. The matrix is stored in band triangular storage mode. These subprograms set x to one of the expressions: x ← Ax, x ← ATx, or for complex data,
The matrix A is either referenced using its upper or lower triangular part and is unit or nonunit triangular. The character flags UPLO, TRANS, and DIAGNL determine the part of the matrix used and the operation performed.
Matrix-Vector Solve, Triangular
CALL STRSV (UPLO, TRANS, DIAGNL, N, SA, LDA, SX, INCX)
CALL DTRSV (UPLO, TRANS, DIAGNL, N, DA, LDA, DX, INCX)
CALL CTRSV (UPLO, TRANS, DIAGNL, N, CA, LDA, CX, INCX)
CALL ZTRSV (UPLO, TRANS, DIAGNL, N, ZA, LDA, ZX, INCX)
For all data types, A is an N × N triangular matrix. These subprograms solve x for one of the expressions: x ← A-1x, x ← (A-1)Tx, or for complex data,
The matrix A is either referenced using its upper or lower triangular part and is unit or nonunit triangular. The character flags UPLO, TRANS, and DIAGNL determine the part of the matrix used and the operation performed.
Matrix-Vector Solve, Triangular and Banded
CALL STBSV (UPLO, TRANS, DIAGNL, N, NCODA, SA, LDA, SX, INCX)
CALL DTBSV (UPLO, TRANS, DIAGNL, N, NCODA, DA, LDA, DX, INCX)
CALL CTBSV (UPLO, TRANS, DIAGNL, N, NCODA, CA, LDA, CX, INCX)
CALL ZTBSV (UPLO, TRANS, DIAGNL, N, NCODA, ZA, LDA, ZX, INCX)
For all data types, A is an N × N triangular matrix with NCODA codiagonals. The matrix is stored in band triangular storage mode. These subprograms solve x for one of the expressions: x ← A-1x, x ← (A-T) -1x, or for complex data,
The matrix A is either referenced using its upper or lower triangular part and is unit or nonunit triangular. The character flags UPLO, TRANS, and DIAGNL determine the part of the matrix used and the operation performed.
Matrix-Vector Solve, Packed Triangular
CALL STPSV (UPLO, TRANS, DIAGNL, N, SAP, SX, INCX)
CALL DTPSV (UPLO, TRANS, DIAGNL, N, DAP, DX, INCX)
CALL CTPSV (UPLO, TRANS, DIAGNL, N, CAP, CX, INCX)
CALL ZTPSV (UPLO, TRANS, DIAGNL, N, ZAP, ZX, INCX)
For all data types,
A is an
N × N packed triangular matrix. These subprograms solve
x for one of the expressions:
x ← A-1x,
x ← (
A-1)
Tx, or for complex data,
The matrix A is either referenced using its packed upper or lower triangular part and is unit or nonunit triangular. The character flags UPLO, TRANS, and DIAGNL determine the part of the matrix used and the operation performed.
Rank-One Matrix Update, General and Real
CALL SGER (M, N, SALPHA, SX, INCX, SY, INCY, SA, LDA)
CALL DGER (M, N, DALPHA, DX, INCX, DY, INCY, DA, LDA)
For all data types, A is an M × N matrix. These subprograms set A ← A + αxyT.
Rank-One Matrix Update, General, Complex, and Transpose
CALL CGERU (M, N, CALPHA, CX, INCX, CY, INCY, CA, LDA)
CALL ZGERU (M, N, ZALPHA, ZX, INCX, ZY, INCY, ZA, LDA)
For all data types, A is an M × N matrix. These subprograms set A ← A + αxyT.
Rank-One Matrix Update, General, Complex, and Conjugate Transpose
CALL CGERC (M, N, CALPHA, CX, INCX, CY, INCY, CA, LDA)
CALL ZGERC (M, N, ZALPHA, ZX, INCX, ZY, INCY, ZA, LDA)
For all data types, A is an M × N matrix. These subprograms set
Rank-One Matrix Update, Hermitian and Conjugate Transpose
CALL CHER (UPLO, N, SALPHA, CX, INCX, CA, LDA)
CALL ZHER (UPLO, N, DALPHA, ZX, INCX, ZA, LDA)
For all data types, A is an N × N matrix. These subprograms set
where A is Hermitian. The matrix A is either referenced by its upper or lower triangular part. The character flag UPLO determines the part used. CAUTION: Notice the scalar parameter α is real, and the data in the matrix and vector are complex.
Rank-One Matrix Update, Packed Hermitian and Conjugate Transpose
CALL CHPR (UPLO, N, SALPHA, CX, INCX, CAP)
CALL ZHPR (UPLO, N, DALPHA, ZX, INCX, ZAP)
For all data types, A is an N × N matrix. These subprograms set
where
A is
packed Hermitian. The matrix
A is either referenced by its upper or lower triangular part. The character flag
UPLO determines the part used. CAUTION: Notice the scalar parameter
α is real, and the data in the matrix and vector are complex.
Rank-Two Matrix Update, Hermitian and Conjugate Transpose
CALL CHER2 (UPLO, N, CALPHA, CX, INCX, CY, INCY, CA, LDA)
CALL ZHER2 (UPLO, N, ZALPHA, ZX, INCX, ZY, INCY, ZA, LDA)
For all data types, A is an N × N matrix. These subprograms set
where A is an Hermitian matrix. The matrix A is either referenced by its upper or lower triangular part. The character flag UPLO determines the part used.
Rank-Two Matrix Update, Packed Hermitian and Conjugate Transpose
CALL CHPR2 (UPLO, N, CALPHA, CX, INCX, CY, INCY, CAP)
CALL ZHPR2 (UPLO, N, ZALPHA, ZX, INCX, ZY, INCY, ZAP)
For all data types, A is an N × N matrix. These subprograms set
where A is a packed Hermitian matrix. The matrix A is either referenced by its upper or lower triangular part. The character flag UPLO determines the part used.
Rank-One Matrix Update, Symmetric and Real
CALL SSYR (UPLO, N, SALPHA, SX, INCX, SA, LDA)
CALL DSYR (UPLO, N, DALPHA, DX, INCX, DA, LDA)
For all data types, A is an N × N matrix. These subprograms set A ← A + αxxT where A is a symmetric matrix. The matrix A is either referenced by its upper or lower triangular part. The character flag UPLO determines the part used.
Rank-One Matrix Update, Packed Symmetric and Real
CALL SSPR (UPLO, N, SALPHA, SX, INCX, SAP)
CALL DSPR (UPLO, N, DALPHA, DX, INCX, DAP)
For all data types, A is an N × N matrix. These subprograms set A ← A + αxxT where A is a packed symmetric matrix. The matrix A is either referenced using the packed upper or lower triangular part. The character flag UPLO determines the part used.
Rank-One Matrix Update, Packed Hermitian
CALL CHPR (UPLO, N, SALPHA, CX, INCX, CAP)
CALL ZHPR (UPLO, N, DALPHA, ZX, INCX, ZAP)
For all data types,
A is an
N × N matrix. These subprograms set
A ← A +
αxxT where
A is a
packed Hermitian matrix. The matrix
A is either referenced using the packed upper or lower triangular part. The character flag
UPLO determines the part used.
Rank-Two Matrix Update, Symmetric and Real
CALL SSYR2 (UPLO, N, SALPHA, SX, INCX, SY, INCY, SA, LDA)
CALL DSYR2 (UPLO, N, DALPHA, DX, INCX, DY, INCY, DA, LDA)
For all data types, A is an N × N matrix. These subprograms set A ← A + αxyT + αyxT, where A is a symmetric matrix. The matrix A is referenced by its upper or lower triangular part. The character flag UPLO determines the part used.
Rank-Two Matrix Update, Packed Symmetric and Real
CALL SSPR2 (UPLO, N, SALPHA, SX, INCX, SY, INCY, SAP)
CALL DSPR2 (UPLO, N, DALPHA, DX, INCX, DY, INCY, DAP)
For all data types, A is an N × N matrix. These subprograms set A ← A + αxyT + αyxT, where A is a packed symmetric matrix. The matrix A is referenced by its upper or lower triangular part. The character flag UPLO determines the part used.
Matrix-Matrix Multiply, General
CALL SGEMM (TRANSA, TRANSB, M, N, K, SALPHA, SA, LDA, SB, LDB, SBETA, SC, LDC)
CALL DGEMM (TRANSA, TRANSB, M, N, K, DALPHA, DA, LDA, DB, LDB, DBETA, DC, LDC)
CALL CGEMM (TRANSA, TRANSB, M, N, K, CALPHA, CA, LDA, CB, LDB, CBETA, CC, LDC)
CALL ZGEMM (TRANSA, TRANSB, M, N, K, ZALPHA, ZA, LDA, ZB, LDB, ZBETA, ZC, LDC)
For all data types, these subprograms set CM×N to one of the expressions:
The character flags TRANSA and TRANSB determine the operation to be performed. Each matrix product has dimensions that follow from the fact that C has dimension M × N.
Matrix-Matrix Multiply, Symmetric
CALL SSYMM (SIDE, UPLO, M, N, SALPHA, SA, LDA, SB, LDB, SBETA, SC, LDC)
CALL DSYMM (SIDE, UPLO, M, N, DALPHA, DA, LDA, DB, LDB, DBETA, DC, LDC)
CALL CSYMM (SIDE, UPLO, M, N, CALPHA, CA, LDA, CB, LDB, CBETA, CC, LDC)
CALL ZSYMM (SIDE, UPLO, M, N, ZALPHA, ZA, LDA, ZB, LDB, ZBETA, ZC, LDC)
For all data types, these subprograms set CM×N to one of the expressions: C ← αAB + βC or C ← αBA + βC, where A is a symmetric matrix. The matrix A is referenced either by its upper or lower triangular part. The character flags SIDE and UPLO determine the part of the matrix used and the operation performed.
Matrix-Matrix Multiply, Hermitian
CALL CHEMM (SIDE, UPLO, M, N, CALPHA, CA, LDA, CB, LDB, CBETA, CC, LDC)
CALL ZHEMM (SIDE, UPLO, M, N, ZALPHA, ZA, LDA, ZB, LDB, ZBETA, ZC, LDC)
For all data types, these subprograms set CM×N to one of the expressions: C ← αAB + βC or C ← αBA + βC, where A is an Hermitian matrix. The matrix A is referenced either by its upper or lower triangular part. The character flags SIDE and UPLO determine the part of the matrix used and the operation performed.
Rank-k Update, Symmetric
CALL SSYRK (UPLO, TRANS, N, K, SALPHA, SA, LDA, SBETA, SC, LDC)
CALL DSYRK (UPLO, TRANS, N, K, DALPHA, DA, LDA, DBETA, DC, LDC)
CALL CSYRK (UPLO, TRANS, N, K, CALPHA, CA, LDA, CBETA, CC, LDC)
CALL ZSYRK (UPLO, TRANS, N, K, ZALPHA, ZA, LDA, ZBETA, ZC, LDC)
For all data types, these subprograms set CM×N to one of the expressions: C ← αAAT + βC or C ← αATA + βC. The matrix C is referenced either by its upper or lower triangular part. The character flags UPLO and TRANS determine the part of the matrix used and the operation performed. In subprogram CSYRK and ZSYRK, only values ’N’ or ’T’ are allowed for TRANS; ’C’ is not acceptable.
Rank-k Update, Hermitian
CALL CHERK (UPLO, TRANS, N, K, SALPHA, CA, LDA, SBETA, CC, LDC)
CALL ZHERK (UPLO, TRANS, N, K, DALPHA, ZA, LDA, DBETA, ZC, LDC)
For all data types, these subprograms set CN× N to one of the expressions:
The matrix C is referenced either by its upper or lower triangular part. The character flags UPLO and TRANS determine the part of the matrix used and the operation performed. CAUTION: Notice the scalar parameters α and β are real, and the data in the matrices are complex. Only values ’N’or ’C’are allowed for TRANS; ’T’is not acceptable.
Rank-2k, Symmetric
CALL SSYR2K (UPLO, TRANS, N, K, SALPHA, SA, LDA, SB, LDB, SBETA, SC, LDC)
CALL DSYR2K (UPLO, TRANS, N, K, DALPHA, DA, LDA, DB, LDB, DBETA, DC, LDC)
CALL CSYR2K (UPLO, TRANS, N, K, CALPHA, CA, LDA, CB, LDB, CBETA, CC, LDC)
CALL ZSYR2K (UPLO, TRANS, N, K, ZALPHA, ZA, LDA, ZB, LDB, ZBETA, ZC, LDC)
For all data types, these subprograms set CN× N to one of the expressions:
The matrix C is referenced either by its upper or lower triangular part. The character flags UPLO and TRANS determine the part of the matrix used and the operation performed. In subprogram CSYR2K and ZSYR2K, only values ’N’or ’T’ are allowed for TRANS; ’C’is not acceptable.
Rank-2k, Hermitian
CALL CHER2K (UPLO, TRANS, N, K, CALPHA, CA, LDA, CB, LDB, SBETA, CC, LDC)
CALL ZHER2K (UPLO, TRANS, N, K, ZALPHA, ZA, LDA, ZB, LDB, DBETA, ZC, LDC)
For all data types, these subprograms set CN× N to one of the expressions:
The matrix C is referenced either by its upper or lower triangular part. The character flags UPLO and TRANS determine the part of the matrix used and the operation performed. CAUTION: Notice the scalar parameter β is real, and the data in the matrices are complex. In subprogram CHER2K and ZHER2K, only values ’N’ or ’C’are allowed for TRANS; ’T’is not acceptable.
Matrix-Matrix Multiply, Triangular
CALL STRMM (SIDE, UPLO, TRANSA, DIAGNL, M, N, SALPHA, SA, LDA, SB, LDB)
CALL DTRMM (SIDE, UPLO, TRANSA, DIAGNL, M, N, DALPHA, DA, LDA, DB, LDB)
CALL CTRMM (SIDE, UPLO, TRANSA, DIAGNL, M, N, CALPHA, CA, LDA, CB,LDB)
CALL ZTRMM (SIDE, UPLO, TRANSA, DIAGNL, M, N, ZALPHA, ZA, LDA, ZB, LDB)
For all data types, these subprograms set BM×N to one of the_expressions:
or for complex data,
where A is a triangular matrix. The matrix A is either referenced using its upper or lower triangular part and is unit or nonunit triangular. The character flags SIDE, UPLO, TRANSA, and DIAGNL determine the part of the matrix used and the operation performed.
Matrix-Matrix Solve, Triangular
CALL STRSM (SIDE, UPLO, TRANSA, DIAGNL, M, N, SALPHA, SA, LDA, SB, LDB)
CALL DTRSM (SIDE, UPLO, TRANSA, DIAGNL, M, N, DALPHA, DA, LDA, DB, LDB)
CALL CTRSM (SIDE, UPLO, TRANSA, DIAGNL, M, N, CALPHA, CA, LDA, CB, LDB)
CALL ZTRSM (SIDE, UPLO, TRANSA, DIAGNL, M, N, ZALPHA, ZA, LDA, ZB, LDB)
For all data types, these subprograms set BM×N to one of the expressions:
or for complex data,
where A is a triangular matrix. The matrix A is either referenced using its upper or lower triangular part and is unit or nonunit triangular. The character flags SIDE, UPLO, TRANSA, and DIAGNL determine the part of the matrix used and the operation performed.