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.