CAXPY
constant times a vector plus a vector. //常數乘以一個向量加上一個向量。
CCOPY
copies a vector x to a vector y.//復制一個向量x到y的向量。
CDOTC
forms the dot product of two vectors, conjugating the first vector.//結合第一個向量,形成了兩個向量的點積
CDOTU
forms the dot product of two vectors.//形成了兩個向量的點積。
CGBMV
performs one of the matrix-vector operations
* CGEMM performs one of the matrix-matrix operations
*
* C := alpha*op( A )*op( B ) + beta*C,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = X**T or op( X ) = X**H,
*
* alpha and beta are scalars, and A, B and C are matrices, with op( A )
* an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
CGEMM
performs one of the matrix-matrix operations
*
* C := alpha*op( A )*op( B ) + beta*C,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = X**T or op( X ) = X**H,
*
* alpha and beta are scalars, and A, B and C are matrices, with op( A )
* an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
*
CGEMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or
*
* y := alpha*A**H*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
CGERC
performs the rank 1 operation
*
* A := alpha*x*y**H + A,
*
* where alpha is a scalar, x is an m element vector, y is an n element
* vector and A is an m by n matrix.
CGERU
performs the rank 1 operation
*
* A := alpha*x*y**T + A,
*
* where alpha is a scalar, x is an m element vector, y is an n element
* vector and A is an m by n matrix.
CHBMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n hermitian band matrix, with k super-diagonals.
CHEMM
performs one of the matrix-matrix operations
*
* C := alpha*A*B + beta*C,
*
* or
*
* C := alpha*B*A + beta*C,
*
* where alpha and beta are scalars, A is an hermitian matrix and B and
* C are m by n matrices.
CHEMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n hermitian matrix.
CHER
performs the hermitian rank 1 operation
*
* A := alpha*x*x**H + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n hermitian matrix.
CHER2
performs the hermitian rank 2 operation
*
* A := alpha*x*y**H + conjg( alpha )*y*x**H + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an n
* by n hermitian matrix.
CHER2K
performs one of the hermitian rank 2k operations
*
* C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C,
*
* or
*
* C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C,
*
* where alpha and beta are scalars with beta real, C is an n by n
* hermitian matrix and A and B are n by k matrices in the first case
* and k by n matrices in the second case.
CHERK
performs one of the hermitian rank k operations
*
* C := alpha*A*A**H + beta*C,
*
* or
*
* C := alpha*A**H*A + beta*C,
*
* where alpha and beta are real scalars, C is an n by n hermitian
* matrix and A is an n by k matrix in the first case and a k by n
* matrix in the second case.
CHPMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n hermitian matrix, supplied in packed form.
CHPR
performs the hermitian rank 1 operation
*
* A := alpha*x*x**H + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n hermitian matrix, supplied in packed form.
CHPR2
performs the hermitian rank 2 operation
*
* A := alpha*x*y**H + conjg( alpha )*y*x**H + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an
* n by n hermitian matrix, supplied in packed form.
CROTG
determines a complex Givens rotation.//確定一個復雜的給定的旋轉。
CSCAL
scales a vector by a constant.// 用一個常數測量向量
CSROT
applies a plane rotation, where the cos and sin (c and s) are real
and the vectors cx and cy are complex.
CSSCAL
scales a complex vector by a real constant.//用一個實數測量一個復雜向量
CSWAP
interchanges two vectors.//交換兩個向量
CSYMM
performs one of the matrix-matrix operations
*
* C := alpha*A*B + beta*C,
*
* or
*
* C := alpha*B*A + beta*C,
*
* where alpha and beta are scalars, A is a symmetric matrix and B and
* C are m by n matrices.
CSYR2K
performs one of the symmetric rank 2k operations
*
* C := alpha*A*B**T + alpha*B*A**T + beta*C,
*
* or
*
* C := alpha*A**T*B + alpha*B**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A and B are n by k matrices in the first case and k by n
* matrices in the second case.
CSYRK
performs one of the symmetric rank k operations
*
* C := alpha*A*A**T + beta*C,
*
* or
*
* C := alpha*A**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A is an n by k matrix in the first case and a k by n matrix
* in the second case.
CTBMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x, or x := A**H*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular band matrix, with ( k + 1 ) diagonals.
DTBSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular band matrix, with ( k + 1 )
* diagonals.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
*
CTBSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b, or A**H*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular band matrix, with ( k + 1 )
* diagonals.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
CTPMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x, or x := A**H*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix, supplied in packed form.
CTPSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b, or A**H*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix, supplied in packed form.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
CTRMM
performs one of the matrix-matrix operations
*
* B := alpha*op( A )*B, or B := alpha*B*op( A )
*
* where alpha is a scalar, B is an m by n matrix, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T or op( A ) = A**H.
CTRMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x, or x := A**H*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix.
CTRSM
solves one of the matrix equations
*
* op( A )*X = alpha*B, or X*op( A ) = alpha*B,
*
* where alpha is a scalar, X and B are m by n matrices, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T or op( A ) = A**H.
*
* The matrix X is overwritten on B.
CTRSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b, or A**H*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
DASUM
takes the sum of the absolute values.//求絕對值的和
DAXPY
constant times a vector plus a vector.//常數乘以一個向量加上一個向量
DCABS1
computes absolute value of a double complex number.//計算一個雙精度復數的絕對值
DCOPY
copies a vector, x, to a vector, y.//把x向量 拷貝到Y
DDOT
forms the dot product of two vectors.
* uses unrolled loops for increments equal to one.
* uses unrolled loops for increments equal to one.
* uses unrolled loops for increments equal to one.
DGBMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n band matrix, with kl sub-diagonals and ku super-diagonals.
DGEMM
performs one of the matrix-matrix operations
*
* C := alpha*op( A )*op( B ) + beta*C,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = X**T,
*
* alpha and beta are scalars, and A, B and C are matrices, with op( A )
* an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
*
DGEMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
DGER
performs the rank 1 operation
*
* A := alpha*x*y**T + A,
*
* where alpha is a scalar, x is an m element vector, y is an n element
* vector and A is an m by n matrix.
DNRM2
returns the euclidean norm of a vector via the function
* name, so that
*
* DNRM2 := sqrt( x'*x )
DROT
applies a plane rotation.//運用平面旋轉。
DROTG
construct givens plane rotation.//構建給定的平面旋轉
DROTM
* APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX
*
* (DX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN
* (DY**T)
*
* DX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX .GE. 0, ELSE
* LX = (-INCX)*N, AND SIMILARLY FOR SY USING LY AND INCY.
* WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS..
*
* DFLAG=-1.D0 DFLAG=0.D0 DFLAG=1.D0 DFLAG=-2.D0
*
* (DH11 DH12) (1.D0 DH12) (DH11 1.D0) (1.D0 0.D0)
* H=( ) ( ) ( ) ( )
* (DH21 DH22), (DH21 1.D0), (-1.D0 DH22), (0.D0 1.D0).
* SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.
DROTMG
* CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS
* THE SECOND COMPONENT OF THE 2-VECTOR (DSQRT(DD1)*DX1,DSQRT(DD2)*
* DY2)**T.
* WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS..
*
* DFLAG=-1.D0 DFLAG=0.D0 DFLAG=1.D0 DFLAG=-2.D0
*
* (DH11 DH12) (1.D0 DH12) (DH11 1.D0) (1.D0 0.D0)
* H=( ) ( ) ( ) ( )
* (DH21 DH22), (DH21 1.D0), (-1.D0 DH22), (0.D0 1.D0).
* LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22
* RESPECTIVELY. (VALUES OF 1.D0, -1.D0, OR 0.D0 IMPLIED BY THE
* VALUE OF DPARAM(1) ARE NOT STORED IN DPARAM.)
*
* THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE
* INEXACT. THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE
* OF DD1 AND DD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM.
DSBMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n symmetric band matrix, with k super-diagonals.
DSCAL
scales a vector by a constant.//用一個常數掃描一個向量
DSDOT
* Compute the inner product of two vectors with extended
* precision accumulation and result.
*
* Returns D.P. dot product accumulated in D.P., for S.P. SX and SY
* DSDOT = sum for I = 0 to N-1 of SX(LX+I*INCX) * SY(LY+I*INCY),
* where LX = 1 if INCX .GE. 0, else LX = 1+(1-N)*INCX, and LY is
* defined in a similar way using INCY.
DSPMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n symmetric matrix, supplied in packed form.
* uses unrolled loops for increment equal to one.
DSPR
performs the symmetric rank 1 operation
*
* A := alpha*x*x**T + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n symmetric matrix, supplied in packed form.
DSPR2
performs the symmetric rank 2 operation
*
* A := alpha*x*y**T + alpha*y*x**T + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an
* n by n symmetric matrix, supplied in packed form.
DSWAP
* interchanges two vectors.//交換兩個向量
* uses unrolled loops for increments equal one.//增量循環為1？？？
DSYMM
performs one of the matrix-matrix operations
*
* C := alpha*A*B + beta*C,
*
* or
*
* C := alpha*B*A + beta*C,
*
* where alpha and beta are scalars, A is a symmetric matrix and B and
* C are m by n matrices.
DSYMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n symmetric matrix.
DSYR
performs the symmetric rank 1 operation
*
* A := alpha*x*x**T + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n symmetric matrix.
*
DSYR2
performs the symmetric rank 2 operation
*
* A := alpha*x*y**T + alpha*y*x**T + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an n
* by n symmetric matrix.
DSYR2K
performs one of the symmetric rank 2k operations
*
* C := alpha*A*B**T + alpha*B*A**T + beta*C,
*
* or
*
* C := alpha*A**T*B + alpha*B**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A and B are n by k matrices in the first case and k by n
* matrices in the second case.
DSYRK
performs one of the symmetric rank k operations
*
* C := alpha*A*A**T + beta*C,
*
* or
*
* C := alpha*A**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A is an n by k matrix in the first case and a k by n matrix
* in the second case.
DTBMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
DTPMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix, supplied in packed form.
DTPSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix, supplied in packed form.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
*
DTRMM
performs one of the matrix-matrix operations
*
* B := alpha*op( A )*B, or B := alpha*B*op( A ),
*
* where alpha is a scalar, B is an m by n matrix, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T.
DTRMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix.
DTRSM
solves one of the matrix equations
*
* op( A )*X = alpha*B, or X*op( A ) = alpha*B,
*
* where alpha is a scalar, X and B are m by n matrices, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T.
*
* The matrix X is overwritten on B.
DTRSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
DZASUM
takes the sum of the absolute values.
DZNRM2
returns the euclidean norm of a vector via the function
* name, so that
*
* DZNRM2 := sqrt( x**H*x )
ICAMAX
finds the index of element having max. absolute value.
IDAMAX
finds the index of element having max. absolute value.//找到最大絕對值
ISAMAX
finds the index of element having max. absolute value.
IZAMAX
finds the index of element having max. absolute value.
LSAME
returns .TRUE. if CA is the same letter as CB regardless of
SASUM
takes the sum of the absolute values.
SAXPY
constant times a vector plus a vector.
SCABS1
computes absolute value of a complex number
SCASUM
takes the sum of the absolute values of a complex vector and
* returns a single precision result.
* uses unrolled loops for increments equal to one
* uses unrolled loops for increment equal to one.
* case.
SCNRM2
returns the euclidean norm of a vector via the function
* name, so that
*
* SCNRM2 := sqrt( x**H*x )
*
SCOPY
copies a vector, x, to a vector, y.
* uses unrolled loops for increments equal to 1.
SDOT
forms the dot product of two vectors.
* uses unrolled loops for increments equal to one.
SDSDOT
* Compute the inner product of two vectors with extended
* precision accumulation.
*
* Returns S.P. result with dot product accumulated in D.P.
* SDSDOT = SB + sum for I = 0 to N-1 of SX(LX+I*INCX)*SY(LY+I*INCY),
* where LX = 1 if INCX .GE. 0, else LX = 1+(1-N)*INCX, and LY is
* defined in a similar way using INCY.
SGBMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n band matrix, with kl sub-diagonals and ku super-diagonals.
SGEMM
performs one of the matrix-matrix operations
*
* C := alpha*op( A )*op( B ) + beta*C,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = X**T,
*
* alpha and beta are scalars, and A, B and C are matrices, with op( A )
* an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
*
SGEMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
SGER
performs the rank 1 operation
*
* A := alpha*x*y**T + A,
*
* where alpha is a scalar, x is an m element vector, y is an n element
* vector and A is an m by n matrix.
SNRM2
returns the euclidean norm of a vector via the function
* name, so that
*
* SNRM2 := sqrt( x'*x ).
SROT
applies a plane rotation.
SROTG
construct givens plane rotation.
SROTM
* APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX
*
* (SX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF SX ARE IN
* (SX**T)
*
* SX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX .GE. 0, ELSE
* LX = (-INCX)*N, AND SIMILARLY FOR SY USING USING LY AND INCY.
* WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS..
*
* SFLAG=-1.E0 SFLAG=0.E0 SFLAG=1.E0 SFLAG=-2.E0
*
* (SH11 SH12) (1.E0 SH12) (SH11 1.E0) (1.E0 0.E0)
* H=( ) ( ) ( ) ( )
* (SH21 SH22), (SH21 1.E0), (-1.E0 SH22), (0.E0 1.E0).
* SEE SROTMG FOR A DESCRIPTION OF DATA STORAGE IN SPARAM.
*
SROTMG
* CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS
* THE SECOND COMPONENT OF THE 2-VECTOR (SQRT(SD1)*SX1,SQRT(SD2)*
* SY2)**T.
* WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS..
*
* SFLAG=-1.E0 SFLAG=0.E0 SFLAG=1.E0 SFLAG=-2.E0
*
* (SH11 SH12) (1.E0 SH12) (SH11 1.E0) (1.E0 0.E0)
* H=( ) ( ) ( ) ( )
* (SH21 SH22), (SH21 1.E0), (-1.E0 SH22), (0.E0 1.E0).
* LOCATIONS 2-4 OF SPARAM CONTAIN SH11,SH21,SH12, AND SH22
* RESPECTIVELY. (VALUES OF 1.E0, -1.E0, OR 0.E0 IMPLIED BY THE
* VALUE OF SPARAM(1) ARE NOT STORED IN SPARAM.)
*
* THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE
* INEXACT. THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE
* OF SD1 AND SD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM.
*
*
SSBMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n symmetric band matrix, with k super-diagonals.
*
SSCAL
* scales a vector by a constant.
* uses unrolled loops for increment equal to 1.
SSPMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n symmetric matrix, supplied in packed form.
*
* Arg
SSPR
performs the symmetric rank 1 operation
*
* A := alpha*x*x**T + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n symmetric matrix, supplied in packed form.
*
SSPR2
performs the symmetric rank 2 operation
*
* A := alpha*x*y**T + alpha*y*x**T + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an
* n by n symmetric matrix, supplied in packed form.
SSWAP
* interchanges two vectors.
* uses unrolled loops for increments equal to 1.
*
SSYMM
performs one of the matrix-matrix operations
*
* C := alpha*A*B + beta*C,
*
* or
*
* C := alpha*B*A + beta*C,
*
* where alpha and beta are scalars, A is a symmetric matrix and B and
* C are m by n matrices.
SSYMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n symmetric matrix.
SSYR
performs the symmetric rank 1 operation
*
* A := alpha*x*x**T + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n symmetric matrix.
SSYR2
performs the symmetric rank 2 operation
*
* A := alpha*x*y**T + alpha*y*x**T + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an n
* by n symmetric matrix.
SSYR2K
performs one of the symmetric rank 2k operations
*
* C := alpha*A*B**T + alpha*B*A**T + beta*C,
*
* or
*
* C := alpha*A**T*B + alpha*B**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A and B are n by k matrices in the first case and k by n
* matrices in the second case.
SSYRK
performs one of the symmetric rank k operations
*
* C := alpha*A*A**T + beta*C,
*
* or
*
* C := alpha*A**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A is an n by k matrix in the first case and a k by n matrix
* in the second case.
STBMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular band matrix, with ( k + 1 ) diagonals.
*
STBSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular band matrix, with ( k + 1 )
* diagonals.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
*
STPMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix, supplied in packed form.
*
STPSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix, supplied in packed form.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
*
STRMM
performs one of the matrix-matrix operations
*
* B := alpha*op( A )*B, or B := alpha*B*op( A ),
*
* where alpha is a scalar, B is an m by n matrix, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T.
STRMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix.
STRSM
solves one of the matrix equations
*
* op( A )*X = alpha*B, or X*op( A ) = alpha*B,
*
* where alpha is a scalar, X and B are m by n matrices, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T.
*
* The matrix X is overwritten on B.
STRSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
XERBLA
is an error handler for the LAPACK routines.
* It is called by an LAPACK routine if an input parameter has an
* invalid value. A message is printed and execution stops.
*
* Installers may consider modifying the STOP statement in order to
* call system-specific exception-handling facilities.
*
ZAXPY
constant times a vector plus a vector.
ZCOPY
copies a vector, x, to a vector, y.
ZDOTC
forms the dot product of a vector.
ZDOTU
forms the dot product of two vectors.
ZDROT
* Applies a plane rotation, where the cos and sin (c and s) are real
* and the vectors cx and cy are complex.
ZDSCAL
scales a vector by a constant.
ZGBMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or
*
* y := alpha*A**H*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n band matrix, with kl sub-diagonals and ku super-diagonals.
*
ZGEMM
performs one of the matrix-matrix operations
*
* C := alpha*op( A )*op( B ) + beta*C,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = X**T or op( X ) = X**H,
*
* alpha and beta are scalars, and A, B and C are matrices, with op( A )
* an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
*
ZGEMV
performs one of the matrix-vector operations
*
* y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or
*
* y := alpha*A**H*x + beta*y,
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
ZGERC
performs the rank 1 operation
*
* A := alpha*x*y**H + A,
*
* where alpha is a scalar, x is an m element vector, y is an n element
* vector and A is an m by n matrix.
ZGERU
performs the rank 1 operation
*
* A := alpha*x*y**T + A,
*
* where alpha is a scalar, x is an m element vector, y is an n element
* vector and A is an m by n matrix.
ZHBMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n hermitian band matrix, with k super-diagonals.
*
ZHEMM
performs one of the matrix-matrix operations
*
* C := alpha*A*B + beta*C,
*
* or
*
* C := alpha*B*A + beta*C,
*
* where alpha and beta are scalars, A is an hermitian matrix and B and
* C are m by n matrices.
ZHEMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n hermitian matrix.
ZHER
performs the hermitian rank 1 operation
*
* A := alpha*x*x**H + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n hermitian matrix.
ZHER2
performs the hermitian rank 2 operation
*
* A := alpha*x*y**H + conjg( alpha )*y*x**H + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an n
* by n hermitian matrix.
*
ZHER2K
performs one of the hermitian rank 2k operations
*
* C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C,
*
* or
*
* C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C,
*
* where alpha and beta are scalars with beta real, C is an n by n
* hermitian matrix and A and B are n by k matrices in the first case
* and k by n matrices in the second case.
*
ZHERK
performs one of the hermitian rank k operations
*
* C := alpha*A*A**H + beta*C,
*
* or
*
* C := alpha*A**H*A + beta*C,
*
* where alpha and beta are real scalars, C is an n by n hermitian
* matrix and A is an n by k matrix in the first case and a k by n
* matrix in the second case.
ZHPMV
performs the matrix-vector operation
*
* y := alpha*A*x + beta*y,
*
* where alpha and beta are scalars, x and y are n element vectors and
* A is an n by n hermitian matrix, supplied in packed form.
*
ZHPR
performs the hermitian rank 1 operation
*
* A := alpha*x*x**H + A,
*
* where alpha is a real scalar, x is an n element vector and A is an
* n by n hermitian matrix, supplied in packed form.
ZHPR2
performs the hermitian rank 2 operation
*
* A := alpha*x*y**H + conjg( alpha )*y*x**H + A,
*
* where alpha is a scalar, x and y are n element vectors and A is an
* n by n hermitian matrix, supplied in packed form.
ZROTG
determines a double complex Givens rotation.
ZSCAL
scales a vector by a constant.
ZSWAP
interchanges two vectors.
ZSYMM
performs one of the matrix-matrix operations
*
* C := alpha*A*B + beta*C,
*
* or
*
* C := alpha*B*A + beta*C,
*
* where alpha and beta are scalars, A is a symmetric matrix and B and
* C are m by n matrices.
ZSYR2K
performs one of the symmetric rank 2k operations
*
* C := alpha*A*B**T + alpha*B*A**T + beta*C,
*
* or
*
* C := alpha*A**T*B + alpha*B**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A and B are n by k matrices in the first case and k by n
* matrices in the second case.
ZSYRK
performs one of the symmetric rank k operations
*
* C := alpha*A*A**T + beta*C,
*
* or
*
* C := alpha*A**T*A + beta*C,
*
* where alpha and beta are scalars, C is an n by n symmetric matrix
* and A is an n by k matrix in the first case and a k by n matrix
* in the second case.
ZTBMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x, or x := A**H*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular band matrix, with ( k + 1 ) diagonals.
*
ZTBSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b, or A**H*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular band matrix, with ( k + 1 )
* diagonals.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
*
ZTPMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x, or x := A**H*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix, supplied in packed form.
*
ZTPSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b, or A**H*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix, supplied in packed form.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.
*
ZTRMM
performs one of the matrix-matrix operations
*
* B := alpha*op( A )*B, or B := alpha*B*op( A )
*
* where alpha is a scalar, B is an m by n matrix, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T or op( A ) = A**H.
*
ZTRMV
performs one of the matrix-vector operations
*
* x := A*x, or x := A**T*x, or x := A**H*x,
*
* where x is an n element vector and A is an n by n unit, or non-unit,
* upper or lower triangular matrix.
ZTRSM
solves one of the matrix equations
*
* op( A )*X = alpha*B, or X*op( A ) = alpha*B,
*
* where alpha is a scalar, X and B are m by n matrices, A is a unit, or
* non-unit, upper or lower triangular matrix and op( A ) is one of
*
* op( A ) = A or op( A ) = A**T or op( A ) = A**H.
*
* The matrix X is overwritten on B.
ZTRSV
solves one of the systems of equations
*
* A*x = b, or A**T*x = b, or A**H*x = b,
*
* where b and x are n element vectors and A is an n by n unit, or
* non-unit, upper or lower triangular matrix.
*
* No test for singularity or near-singularity is included in this
* routine. Such tests must be performed before calling this routine.