Blas 基本函数功能

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.