|
fortran-lapack
|
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_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_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_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_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_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_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_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_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_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_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_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. | |
BLAS level 2: triangular matrix-vector operations.
| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.

| 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.
