Functions/Subroutines | |
| pure subroutine, public | la_caxpy (n, ca, cx, incx, cy, incy) |
| CAXPY: constant times a vector plus a vector. | |
| pure subroutine, public | la_ccopy (n, cx, incx, cy, incy) |
| CCOPY: copies a vector x to a vector y. | |
| pure complex(sp) function, public | la_cdotc (n, cx, incx, cy, incy) |
| CDOTC: forms the dot product of two complex vectors CDOTC = X^H * Y. | |
| pure complex(sp) function, public | la_cdotu (n, cx, incx, cy, incy) |
| CDOTU: forms the dot product of two complex vectors CDOTU = X^T * Y. | |
| pure subroutine, public | la_cgbmv (trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) |
| CGBMV: 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. | |
| pure subroutine, public | la_cgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_cgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_cgerc (m, n, alpha, x, incx, y, incy, a, lda) |
| 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. | |
| pure subroutine, public | la_cgeru (m, n, alpha, x, incx, y, incy, a, lda) |
| 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. | |
| pure subroutine, public | la_chbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_chemm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_chemv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_cher (uplo, n, alpha, x, incx, a, lda) |
| 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. | |
| pure subroutine, public | la_cher2 (uplo, n, alpha, x, incx, y, incy, a, lda) |
| 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. | |
| pure subroutine, public | la_cher2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_cherk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_chpmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_chpr (uplo, n, alpha, x, incx, ap) |
| 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. | |
| pure subroutine, public | la_chpr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| 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. | |
| pure subroutine, public | la_crotg (a, b, c, s) |
| ! | |
| pure subroutine, public | la_cscal (n, ca, cx, incx) |
| CSCAL: scales a vector by a constant. | |
| pure subroutine, public | la_csrot (n, cx, incx, cy, incy, c, s) |
| CSROT: applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78. | |
| pure subroutine, public | la_csscal (n, sa, cx, incx) |
| CSSCAL: scales a complex vector by a real constant. | |
| pure subroutine, public | la_cswap (n, cx, incx, cy, incy) |
| CSWAP: interchanges two vectors. | |
| pure subroutine, public | la_csymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_csyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_csyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| 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. | |
| pure subroutine, public | la_ctbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_ctbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_ctpmv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_ctpsv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_ctrmm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) |
| 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. | |
| pure subroutine, public | la_ctrmv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_ctrsm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) |
| 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. | |
| pure subroutine, public | la_ctrsv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
Function/Subroutine Documentation
◆ la_caxpy()
| pure subroutine, public la_blas_c::la_caxpy | ( | integer(ilp), intent(in) | n, |
| complex(sp), intent(in) | ca, | ||
| complex(sp), dimension(*), intent(in) | cx, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(inout) | cy, | ||
| integer(ilp), intent(in) | incy ) |
CAXPY: constant times a vector plus a vector.
◆ la_ccopy()
| pure subroutine, public la_blas_c::la_ccopy | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(in) | cx, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(out) | cy, | ||
| integer(ilp), intent(in) | incy ) |
CCOPY: copies a vector x to a vector y.
◆ la_cdotc()
| pure complex(sp) function, public la_blas_c::la_cdotc | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(in) | cx, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(in) | cy, | ||
| integer(ilp), intent(in) | incy ) |
CDOTC: forms the dot product of two complex vectors CDOTC = X^H * Y.
◆ la_cdotu()
| pure complex(sp) function, public la_blas_c::la_cdotu | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(in) | cx, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(in) | cy, | ||
| integer(ilp), intent(in) | incy ) |
CDOTU: forms the dot product of two complex vectors CDOTU = X^T * Y.
◆ la_cgbmv()
| pure subroutine, public la_blas_c::la_cgbmv | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CGBMV: 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.
◆ la_cgemm()
| pure subroutine, public la_blas_c::la_cgemm | ( | character, intent(in) | transa, |
| character, intent(in) | transb, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_cgemv()
| pure subroutine, public la_blas_c::la_cgemv | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_cgerc()
| pure subroutine, public la_blas_c::la_cgerc | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
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.
◆ la_cgeru()
| pure subroutine, public la_blas_c::la_cgeru | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
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.
◆ la_chbmv()
| pure subroutine, public la_blas_c::la_chbmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_chemm()
| pure subroutine, public la_blas_c::la_chemm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_chemv()
| pure subroutine, public la_blas_c::la_chemv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_cher()
| pure subroutine, public la_blas_c::la_cher | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
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.
◆ la_cher2()
| pure subroutine, public la_blas_c::la_cher2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
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.
◆ la_cher2k()
| pure subroutine, public la_blas_c::la_cher2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_cherk()
| pure subroutine, public la_blas_c::la_cherk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_chpmv()
| pure subroutine, public la_blas_c::la_chpmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_chpr()
| pure subroutine, public la_blas_c::la_chpr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(inout) | ap ) |
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.
◆ la_chpr2()
| pure subroutine, public la_blas_c::la_chpr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| complex(sp), dimension(*), intent(inout) | ap ) |
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.
◆ la_crotg()
| pure subroutine, public la_blas_c::la_crotg | ( | complex(sp), intent(inout) | a, |
| complex(sp), intent(in) | b, | ||
| real(sp), intent(out) | c, | ||
| complex(sp), intent(out) | s ) |
!
The computation uses the formulas |x| = sqrt( Re(x)**2 + Im(x)**2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|**2 + |b|**2) s = sgn(a) * conjg(b) / sqrt(|a|**2 + |b|**2) When a and b are real and r /= 0, the formulas simplify to r = sgn(a)*sqrt(|a|**2 + |b|**2) c = a / r s = b / r the same as in SROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by SROTG if the signs of a and b are not the same.
◆ la_cscal()
| pure subroutine, public la_blas_c::la_cscal | ( | integer(ilp), intent(in) | n, |
| complex(sp), intent(in) | ca, | ||
| complex(sp), dimension(*), intent(inout) | cx, | ||
| integer(ilp), intent(in) | incx ) |
CSCAL: scales a vector by a constant.
◆ la_csrot()
| pure subroutine, public la_blas_c::la_csrot | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(inout) | cx, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(inout) | cy, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), intent(in) | c, | ||
| real(sp), intent(in) | s ) |
CSROT: applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.
◆ la_csscal()
| pure subroutine, public la_blas_c::la_csscal | ( | integer(ilp), intent(in) | n, |
| real(sp), intent(in) | sa, | ||
| complex(sp), dimension(*), intent(inout) | cx, | ||
| integer(ilp), intent(in) | incx ) |
CSSCAL: scales a complex vector by a real constant.
◆ la_cswap()
| pure subroutine, public la_blas_c::la_cswap | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(inout) | cx, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(sp), dimension(*), intent(inout) | cy, | ||
| integer(ilp), intent(in) | incy ) |
CSWAP: interchanges two vectors.
◆ la_csymm()
| pure subroutine, public la_blas_c::la_csymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_csyr2k()
| pure subroutine, public la_blas_c::la_csyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_csyrk()
| pure subroutine, public la_blas_c::la_csyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), intent(in) | beta, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
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.
◆ la_ctbmv()
| pure subroutine, public la_blas_c::la_ctbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ctbsv()
| pure subroutine, public la_blas_c::la_ctbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ctpmv()
| pure subroutine, public la_blas_c::la_ctpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ctpsv()
| pure subroutine, public la_blas_c::la_ctpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ctrmm()
| pure subroutine, public la_blas_c::la_ctrmm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| character, intent(in) | transa, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
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.
◆ la_ctrmv()
| pure subroutine, public la_blas_c::la_ctrmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ctrsm()
| pure subroutine, public la_blas_c::la_ctrsm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| character, intent(in) | transa, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
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.
◆ la_ctrsv()
| pure subroutine, public la_blas_c::la_ctrsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
