la_blas_c.f90 File Reference

Modules
module	la_blas_c

Functions/Subroutines
pure subroutine, public	la_blas_c::la_caxpy (n, ca, cx, incx, cy, incy)
	CAXPY: constant times a vector plus a vector.
pure subroutine, public	la_blas_c::la_ccopy (n, cx, incx, cy, incy)
	CCOPY: copies a vector x to a vector y.
pure complex(sp) function, public	la_blas_c::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_blas_c::la_cdotu (n, cx, incx, cy, incy)
	CDOTU: forms the dot product of two complex vectors CDOTU = X^T * Y.
pure subroutine, public	la_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::la_crotg (a, b, c, s)
	!
pure subroutine, public	la_blas_c::la_cscal (n, ca, cx, incx)
	CSCAL: scales a vector by a constant.
pure subroutine, public	la_blas_c::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_blas_c::la_csscal (n, sa, cx, incx)
	CSSCAL: scales a complex vector by a real constant.
pure subroutine, public	la_blas_c::la_cswap (n, cx, incx, cy, incy)
	CSWAP: interchanges two vectors.
pure subroutine, public	la_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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_blas_c::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.