BLAS level 2: triangular matrix-vector operations. More...
Functions/Subroutines | |
| pure subroutine, public | la_stbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_dtbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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, upper or lower triangular band matrix, with ( k + 1 ) diagonals. | |
| pure subroutine, public | la_qtbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| QTBMV: 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. | |
| pure subroutine, public | la_stbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_dtbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_qtbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| QTBSV: 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. | |
| pure subroutine, public | la_stpmv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_dtpmv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_qtpmv (uplo, trans, diag, n, ap, x, incx) |
| QTPMV: 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. | |
| pure subroutine, public | la_stpsv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_dtpsv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_qtpsv (uplo, trans, diag, n, ap, x, incx) |
| QTPSV: 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. | |
| pure subroutine, public | la_strmv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_dtrmv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_qtrmv (uplo, trans, diag, n, a, lda, x, incx) |
| QTRMV: 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. | |
| pure subroutine, public | la_strsv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_dtrsv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_qtrsv (uplo, trans, diag, n, a, lda, x, incx) |
| QTRSV: 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. | |
| 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_ztbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_wtbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| WTBMV: 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_ztbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_wtbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| WTBSV: 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_ztpmv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_wtpmv (uplo, trans, diag, n, ap, x, incx) |
| WTPMV: 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_ztpsv (uplo, trans, diag, n, ap, x, incx) |
| 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. | |
| pure subroutine, public | la_wtpsv (uplo, trans, diag, n, ap, x, incx) |
| WTPSV: 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_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_ztrmv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_wtrmv (uplo, trans, diag, n, a, lda, x, incx) |
| WTRMV: 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_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. | |
| pure subroutine, public | la_ztrsv (uplo, trans, diag, n, a, lda, x, incx) |
| 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. | |
| pure subroutine, public | la_wtrsv (uplo, trans, diag, n, a, lda, x, incx) |
| WTRSV: 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. | |
Detailed Description
BLAS level 2: triangular matrix-vector operations.
Function/Subroutine Documentation
◆ la_ctbmv()
| pure subroutine, public la_blas_level2_tri::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_level2_tri::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_level2_tri::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_level2_tri::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_ctrmv()
| pure subroutine, public la_blas_level2_tri::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_ctrsv()
| pure subroutine, public la_blas_level2_tri::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.
◆ la_dtbmv()
| pure subroutine, public la_blas_level2_tri::la_dtbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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, upper or lower triangular band matrix, with ( k + 1 ) diagonals.
◆ la_dtbsv()
| pure subroutine, public la_blas_level2_tri::la_dtbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_dtpmv()
| pure subroutine, public la_blas_level2_tri::la_dtpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_dtpsv()
| pure subroutine, public la_blas_level2_tri::la_dtpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_dtrmv()
| pure subroutine, public la_blas_level2_tri::la_dtrmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_dtrsv()
| pure subroutine, public la_blas_level2_tri::la_dtrsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_qtbmv()
| pure subroutine, public la_blas_level2_tri::la_qtbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
QTBMV: 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.
◆ la_qtbsv()
| pure subroutine, public la_blas_level2_tri::la_qtbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
QTBSV: 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.
◆ la_qtpmv()
| pure subroutine, public la_blas_level2_tri::la_qtpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
QTPMV: 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.
◆ la_qtpsv()
| pure subroutine, public la_blas_level2_tri::la_qtpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
QTPSV: 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.
◆ la_qtrmv()
| pure subroutine, public la_blas_level2_tri::la_qtrmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
QTRMV: 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.
◆ la_qtrsv()
| pure subroutine, public la_blas_level2_tri::la_qtrsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
QTRSV: 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.
◆ la_stbmv()
| pure subroutine, public la_blas_level2_tri::la_stbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_stbsv()
| pure subroutine, public la_blas_level2_tri::la_stbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_stpmv()
| pure subroutine, public la_blas_level2_tri::la_stpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_stpsv()
| pure subroutine, public la_blas_level2_tri::la_stpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_strmv()
| pure subroutine, public la_blas_level2_tri::la_strmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_strsv()
| pure subroutine, public la_blas_level2_tri::la_strsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_wtbmv()
| pure subroutine, public la_blas_level2_tri::la_wtbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
WTBMV: 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_wtbsv()
| pure subroutine, public la_blas_level2_tri::la_wtbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
WTBSV: 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_wtpmv()
| pure subroutine, public la_blas_level2_tri::la_wtpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
WTPMV: 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_wtpsv()
| pure subroutine, public la_blas_level2_tri::la_wtpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
WTPSV: 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_wtrmv()
| pure subroutine, public la_blas_level2_tri::la_wtrmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
WTRMV: 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_wtrsv()
| pure subroutine, public la_blas_level2_tri::la_wtrsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
WTRSV: 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.
◆ la_ztbmv()
| pure subroutine, public la_blas_level2_tri::la_ztbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ztbsv()
| pure subroutine, public la_blas_level2_tri::la_ztbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ztpmv()
| pure subroutine, public la_blas_level2_tri::la_ztpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ztpsv()
| pure subroutine, public la_blas_level2_tri::la_ztpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ztrmv()
| pure subroutine, public la_blas_level2_tri::la_ztrmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
◆ la_ztrsv()
| pure subroutine, public la_blas_level2_tri::la_ztrsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
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.
