BLAS level 2: packed and symmetric-banded matrix-vector operations. More...
Functions/Subroutines | |
| pure subroutine, public | la_ssbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_dsbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_qsbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) |
| QSBMV: 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. | |
| pure subroutine, public | la_sspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_dspmv (uplo, n, alpha, ap, x, incx, beta, y, 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. | |
| pure subroutine, public | la_qspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| QSPMV: 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. | |
| pure subroutine, public | la_sspr (uplo, n, alpha, x, incx, ap) |
| 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. | |
| pure subroutine, public | la_dspr (uplo, n, alpha, x, incx, ap) |
| 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. | |
| pure subroutine, public | la_qspr (uplo, n, alpha, x, incx, ap) |
| QSPR: 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. | |
| pure subroutine, public | la_sspr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| 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. | |
| pure subroutine, public | la_dspr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| 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. | |
| pure subroutine, public | la_qspr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| QSPR2: 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. | |
| 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_zhpmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| 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. | |
| pure subroutine, public | la_whpmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| WHPMV: 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_zhpr (uplo, n, alpha, x, incx, ap) |
| 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. | |
| pure subroutine, public | la_whpr (uplo, n, alpha, x, incx, ap) |
| WHPR: 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_zhpr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| 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. | |
| pure subroutine, public | la_whpr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| WHPR2: 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. | |
Detailed Description
BLAS level 2: packed and symmetric-banded matrix-vector operations.
Function/Subroutine Documentation
◆ la_chpmv()
| pure subroutine, public la_blas_level2_pac::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_level2_pac::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_level2_pac::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_dsbmv()
| pure subroutine, public la_blas_level2_pac::la_dsbmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_dspmv()
| pure subroutine, public la_blas_level2_pac::la_dspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | 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.
◆ la_dspr()
| pure subroutine, public la_blas_level2_pac::la_dspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), dimension(*), intent(inout) | ap ) |
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.
◆ la_dspr2()
| pure subroutine, public la_blas_level2_pac::la_dspr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(dp), dimension(*), intent(inout) | ap ) |
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.
◆ la_qsbmv()
| pure subroutine, public la_blas_level2_pac::la_qsbmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
QSBMV: 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.
◆ la_qspmv()
| pure subroutine, public la_blas_level2_pac::la_qspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
QSPMV: 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.
◆ la_qspr()
| pure subroutine, public la_blas_level2_pac::la_qspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | ap ) |
QSPR: 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.
◆ la_qspr2()
| pure subroutine, public la_blas_level2_pac::la_qspr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), dimension(*), intent(inout) | ap ) |
QSPR2: 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.
◆ la_ssbmv()
| pure subroutine, public la_blas_level2_pac::la_ssbmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_sspmv()
| pure subroutine, public la_blas_level2_pac::la_sspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_sspr()
| pure subroutine, public la_blas_level2_pac::la_sspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | ap ) |
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.
◆ la_sspr2()
| pure subroutine, public la_blas_level2_pac::la_sspr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), dimension(*), intent(inout) | ap ) |
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.
◆ la_whpmv()
| pure subroutine, public la_blas_level2_pac::la_whpmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), intent(in) | beta, | ||
| complex(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
WHPMV: 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_whpr()
| pure subroutine, public la_blas_level2_pac::la_whpr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), dimension(*), intent(inout) | ap ) |
WHPR: 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_whpr2()
| pure subroutine, public la_blas_level2_pac::la_whpr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), intent(in) | alpha, | ||
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(qp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| complex(qp), dimension(*), intent(inout) | ap ) |
WHPR2: 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_zhpmv()
| pure subroutine, public la_blas_level2_pac::la_zhpmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), intent(in) | beta, | ||
| complex(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
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.
◆ la_zhpr()
| pure subroutine, public la_blas_level2_pac::la_zhpr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), dimension(*), intent(inout) | ap ) |
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.
◆ la_zhpr2()
| pure subroutine, public la_blas_level2_pac::la_zhpr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), intent(in) | alpha, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| complex(dp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| complex(dp), dimension(*), intent(inout) | ap ) |
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.
