fortran-lapack
Loading...
Searching...
No Matches
la_lapack_solve_tri_comp Module Reference

Triangular systems: solve, inverse, condition estimation, refinement. More...

Functions/Subroutines

pure subroutine, public la_slatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
 SLATBS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_dlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
 DLATBS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_slatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
 SLATPS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_dlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
 DLATPS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_slatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
 SLATRS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_dlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
 DLATRS: solves one of the triangular systems A *x = s*b or A**T *x = s*b with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_slauu2 (uplo, n, a, lda, info)
 SLAUU2: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.
 
pure subroutine, public la_dlauu2 (uplo, n, a, lda, info)
 DLAUU2: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.
 
pure subroutine, public la_slauum (uplo, n, a, lda, info)
 SLAUUM: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
 
pure subroutine, public la_dlauum (uplo, n, a, lda, info)
 DLAUUM: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
 
pure subroutine, public la_stbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)
 STBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by STBTRS or some other means before entering this routine. STBRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_dtbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)
 DTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by DTBTRS or some other means before entering this routine. DTBRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_stbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
 STBTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_dtbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
 DTBTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_stprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)
 STPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by STPTRS or some other means before entering this routine. STPRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_dtprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)
 DTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by DTPTRS or some other means before entering this routine. DTPRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_stptri (uplo, diag, n, ap, info)
 STPTRI: computes the inverse of a real upper or lower triangular matrix A stored in packed format.
 
pure subroutine, public la_dtptri (uplo, diag, n, ap, info)
 DTPTRI: computes the inverse of a real upper or lower triangular matrix A stored in packed format.
 
pure subroutine, public la_stptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
 STPTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_dtptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
 DTPTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_strrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)
 STRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by STRTRS or some other means before entering this routine. STRRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_dtrrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)
 DTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by DTRTRS or some other means before entering this routine. DTRRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_strti2 (uplo, diag, n, a, lda, info)
 STRTI2: computes the inverse of a real upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.
 
pure subroutine, public la_dtrti2 (uplo, diag, n, a, lda, info)
 DTRTI2: computes the inverse of a real upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.
 
pure subroutine, public la_strtri (uplo, diag, n, a, lda, info)
 STRTRI: computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_dtrtri (uplo, diag, n, a, lda, info)
 DTRTRI: computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_strtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
 STRTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_dtrtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
 DTRTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_stbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)
 STBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_dtbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)
 DTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_stftri (transr, uplo, diag, n, a, info)
 STFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_dtftri (transr, uplo, diag, n, a, info)
 DTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_stpcon (norm, uplo, diag, n, ap, rcond, work, iwork, info)
 STPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_dtpcon (norm, uplo, diag, n, ap, rcond, work, iwork, info)
 DTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_strcon (norm, uplo, diag, n, a, lda, rcond, work, iwork, info)
 STRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_dtrcon (norm, uplo, diag, n, a, lda, rcond, work, iwork, info)
 DTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_clatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
 CLATBS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_zlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
 ZLATBS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_clatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
 CLATPS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_zlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
 ZLATPS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_clatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
 CLATRS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_zlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
 ZLATRS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
 
pure subroutine, public la_clauu2 (uplo, n, a, lda, info)
 CLAUU2: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.
 
pure subroutine, public la_zlauu2 (uplo, n, a, lda, info)
 ZLAUU2: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.
 
pure subroutine, public la_clauum (uplo, n, a, lda, info)
 CLAUUM: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
 
pure subroutine, public la_zlauum (uplo, n, a, lda, info)
 ZLAUUM: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
 
pure subroutine, public la_ctbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 CTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. CTBRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_ztbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 ZTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by ZTBTRS or some other means before entering this routine. ZTBRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_ctbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
 CTBTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_ztbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
 ZTBTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_ctprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 CTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. CTPRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_ztprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 ZTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by ZTPTRS or some other means before entering this routine. ZTPRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_ctptri (uplo, diag, n, ap, info)
 CTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.
 
pure subroutine, public la_ztptri (uplo, diag, n, ap, info)
 ZTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.
 
pure subroutine, public la_ctptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
 CTPTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_ztptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
 ZTPTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_ctrrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 CTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. CTRRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_ztrrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 ZTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by ZTRTRS or some other means before entering this routine. ZTRRFS does not do iterative refinement because doing so cannot improve the backward error.
 
pure subroutine, public la_ctrti2 (uplo, diag, n, a, lda, info)
 CTRTI2: computes the inverse of a complex upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.
 
pure subroutine, public la_ztrti2 (uplo, diag, n, a, lda, info)
 ZTRTI2: computes the inverse of a complex upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.
 
pure subroutine, public la_ctrtri (uplo, diag, n, a, lda, info)
 CTRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_ztrtri (uplo, diag, n, a, lda, info)
 ZTRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_ctrtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
 CTRTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_ztrtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
 ZTRTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
 
pure subroutine, public la_ctbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)
 CTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_ztbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)
 ZTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_ctftri (transr, uplo, diag, n, a, info)
 CTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_ztftri (transr, uplo, diag, n, a, info)
 ZTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
 
pure subroutine, public la_ctpcon (norm, uplo, diag, n, ap, rcond, work, rwork, info)
 CTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_ztpcon (norm, uplo, diag, n, ap, rcond, work, rwork, info)
 ZTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_ctrcon (norm, uplo, diag, n, a, lda, rcond, work, rwork, info)
 CTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 
pure subroutine, public la_ztrcon (norm, uplo, diag, n, a, lda, rcond, work, rwork, info)
 ZTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
 

Detailed Description

Triangular systems: solve, inverse, condition estimation, refinement.

Function/Subroutine Documentation

◆ la_clatbs()

pure subroutine, public la_lapack_solve_tri_comp::la_clatbs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(*), intent(inout) x,
real(sp), intent(out) scale,
real(sp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

CLATBS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_clatps()

pure subroutine, public la_lapack_solve_tri_comp::la_clatps ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(in) ap,
complex(sp), dimension(*), intent(inout) x,
real(sp), intent(out) scale,
real(sp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

CLATPS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_clatrs()

pure subroutine, public la_lapack_solve_tri_comp::la_clatrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(*), intent(inout) x,
real(sp), intent(out) scale,
real(sp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

CLATRS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_clauu2()

pure subroutine, public la_lapack_solve_tri_comp::la_clauu2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

CLAUU2: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_clauum()

pure subroutine, public la_lapack_solve_tri_comp::la_clauum ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

CLAUUM: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_ctbcon()

pure subroutine, public la_lapack_solve_tri_comp::la_ctbcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(sp), intent(out) rcond,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ctbrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_ctbrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
complex(sp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(sp), dimension(*), intent(out) ferr,
real(sp), dimension(*), intent(out) berr,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. CTBRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ctbtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_ctbtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

CTBTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_ctftri()

pure subroutine, public la_lapack_solve_tri_comp::la_ctftri ( character, intent(in) transr,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(sp), dimension(0:*), intent(inout) a,
integer(ilp), intent(out) info )

CTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ctpcon()

pure subroutine, public la_lapack_solve_tri_comp::la_ctpcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(in) ap,
real(sp), intent(out) rcond,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ctprfs()

pure subroutine, public la_lapack_solve_tri_comp::la_ctprfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(*), intent(in) ap,
complex(sp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
complex(sp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(sp), dimension(*), intent(out) ferr,
real(sp), dimension(*), intent(out) berr,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. CTPRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ctptri()

pure subroutine, public la_lapack_solve_tri_comp::la_ctptri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
integer(ilp), intent(out) info )

CTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

Here is the call graph for this function:

◆ la_ctptrs()

pure subroutine, public la_lapack_solve_tri_comp::la_ctptrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(*), intent(in) ap,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

CTPTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_ctrcon()

pure subroutine, public la_lapack_solve_tri_comp::la_ctrcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(sp), intent(out) rcond,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ctrrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_ctrrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
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), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(sp), dimension(*), intent(out) ferr,
real(sp), dimension(*), intent(out) berr,
complex(sp), dimension(*), intent(out) work,
real(sp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

CTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. CTRRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ctrti2()

pure subroutine, public la_lapack_solve_tri_comp::la_ctrti2 ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

CTRTI2: computes the inverse of a complex upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ctrtri()

pure subroutine, public la_lapack_solve_tri_comp::la_ctrtri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

CTRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ctrtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_ctrtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

CTRTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_dlatbs()

pure subroutine, public la_lapack_solve_tri_comp::la_dlatbs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(*), intent(inout) x,
real(dp), intent(out) scale,
real(dp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

DLATBS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_dlatps()

pure subroutine, public la_lapack_solve_tri_comp::la_dlatps ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(in) ap,
real(dp), dimension(*), intent(inout) x,
real(dp), intent(out) scale,
real(dp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

DLATPS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_dlatrs()

pure subroutine, public la_lapack_solve_tri_comp::la_dlatrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(inout) x,
real(dp), intent(out) scale,
real(dp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

DLATRS: solves one of the triangular systems A *x = s*b or A**T *x = s*b with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_dlauu2()

pure subroutine, public la_lapack_solve_tri_comp::la_dlauu2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

DLAUU2: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_dlauum()

pure subroutine, public la_lapack_solve_tri_comp::la_dlauum ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

DLAUUM: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_dtbcon()

pure subroutine, public la_lapack_solve_tri_comp::la_dtbcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(dp), intent(out) rcond,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

DTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_dtbrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_dtbrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
real(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(dp), dimension(*), intent(out) ferr,
real(dp), dimension(*), intent(out) berr,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

DTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by DTBTRS or some other means before entering this routine. DTBRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_dtbtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_dtbtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
real(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

DTBTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_dtftri()

pure subroutine, public la_lapack_solve_tri_comp::la_dtftri ( character, intent(in) transr,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(dp), dimension(0:*), intent(inout) a,
integer(ilp), intent(out) info )

DTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_dtpcon()

pure subroutine, public la_lapack_solve_tri_comp::la_dtpcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(in) ap,
real(dp), intent(out) rcond,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

DTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_dtprfs()

pure subroutine, public la_lapack_solve_tri_comp::la_dtprfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(dp), dimension(*), intent(in) ap,
real(dp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(dp), dimension(*), intent(out) ferr,
real(dp), dimension(*), intent(out) berr,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

DTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by DTPTRS or some other means before entering this routine. DTPRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_dtptri()

pure subroutine, public la_lapack_solve_tri_comp::la_dtptri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(dp), dimension(*), intent(inout) ap,
integer(ilp), intent(out) info )

DTPTRI: computes the inverse of a real upper or lower triangular matrix A stored in packed format.

Here is the call graph for this function:

◆ la_dtptrs()

pure subroutine, public la_lapack_solve_tri_comp::la_dtptrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(dp), dimension(*), intent(in) ap,
real(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

DTPTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_dtrcon()

pure subroutine, public la_lapack_solve_tri_comp::la_dtrcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(dp), intent(out) rcond,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

DTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_dtrrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_dtrrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(dp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
real(dp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(dp), dimension(*), intent(out) ferr,
real(dp), dimension(*), intent(out) berr,
real(dp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

DTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by DTRTRS or some other means before entering this routine. DTRRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_dtrti2()

pure subroutine, public la_lapack_solve_tri_comp::la_dtrti2 ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

DTRTI2: computes the inverse of a real upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_dtrtri()

pure subroutine, public la_lapack_solve_tri_comp::la_dtrtri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

DTRTRI: computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_dtrtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_dtrtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

DTRTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_slatbs()

pure subroutine, public la_lapack_solve_tri_comp::la_slatbs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(*), intent(inout) x,
real(sp), intent(out) scale,
real(sp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

SLATBS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_slatps()

pure subroutine, public la_lapack_solve_tri_comp::la_slatps ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(in) ap,
real(sp), dimension(*), intent(inout) x,
real(sp), intent(out) scale,
real(sp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

SLATPS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_slatrs()

pure subroutine, public la_lapack_solve_tri_comp::la_slatrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(inout) x,
real(sp), intent(out) scale,
real(sp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

SLATRS: solves one of the triangular systems A *x = s*b or A**T*x = s*b with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_slauu2()

pure subroutine, public la_lapack_solve_tri_comp::la_slauu2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

SLAUU2: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_slauum()

pure subroutine, public la_lapack_solve_tri_comp::la_slauum ( character, intent(in) uplo,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

SLAUUM: computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_stbcon()

pure subroutine, public la_lapack_solve_tri_comp::la_stbcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
real(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(sp), intent(out) rcond,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

STBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_stbrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_stbrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
real(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(sp), dimension(*), intent(out) ferr,
real(sp), dimension(*), intent(out) berr,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

STBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by STBTRS or some other means before entering this routine. STBRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_stbtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_stbtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
real(sp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

STBTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_stftri()

pure subroutine, public la_lapack_solve_tri_comp::la_stftri ( character, intent(in) transr,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(sp), dimension(0:*), intent(inout) a,
integer(ilp), intent(out) info )

STFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_stpcon()

pure subroutine, public la_lapack_solve_tri_comp::la_stpcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(in) ap,
real(sp), intent(out) rcond,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

STPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_stprfs()

pure subroutine, public la_lapack_solve_tri_comp::la_stprfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(sp), dimension(*), intent(in) ap,
real(sp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(sp), dimension(*), intent(out) ferr,
real(sp), dimension(*), intent(out) berr,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

STPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by STPTRS or some other means before entering this routine. STPRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_stptri()

pure subroutine, public la_lapack_solve_tri_comp::la_stptri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(sp), dimension(*), intent(inout) ap,
integer(ilp), intent(out) info )

STPTRI: computes the inverse of a real upper or lower triangular matrix A stored in packed format.

Here is the call graph for this function:

◆ la_stptrs()

pure subroutine, public la_lapack_solve_tri_comp::la_stptrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(sp), dimension(*), intent(in) ap,
real(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

STPTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_strcon()

pure subroutine, public la_lapack_solve_tri_comp::la_strcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(sp), intent(out) rcond,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

STRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_strrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_strrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(sp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
real(sp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(sp), dimension(*), intent(out) ferr,
real(sp), dimension(*), intent(out) berr,
real(sp), dimension(*), intent(out) work,
integer(ilp), dimension(*), intent(out) iwork,
integer(ilp), intent(out) info )

STRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by STRTRS or some other means before entering this routine. STRRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_strti2()

pure subroutine, public la_lapack_solve_tri_comp::la_strti2 ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

STRTI2: computes the inverse of a real upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_strtri()

pure subroutine, public la_lapack_solve_tri_comp::la_strtri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
real(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

STRTRI: computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_strtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_strtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
real(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

STRTRS: solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_zlatbs()

pure subroutine, public la_lapack_solve_tri_comp::la_zlatbs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(*), intent(inout) x,
real(dp), intent(out) scale,
real(dp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

ZLATBS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here A**T denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_zlatps()

pure subroutine, public la_lapack_solve_tri_comp::la_zlatps ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(in) ap,
complex(dp), dimension(*), intent(inout) x,
real(dp), intent(out) scale,
real(dp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

ZLATPS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_zlatrs()

pure subroutine, public la_lapack_solve_tri_comp::la_zlatrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
character, intent(in) normin,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(*), intent(inout) x,
real(dp), intent(out) scale,
real(dp), dimension(*), intent(inout) cnorm,
integer(ilp), intent(out) info )

ZLATRS: solves one of the triangular systems A * x = s*b, A**T * x = s*b, or A**H * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, A**T denotes the transpose of A, A**H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

Here is the call graph for this function:

◆ la_zlauu2()

pure subroutine, public la_lapack_solve_tri_comp::la_zlauu2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

ZLAUU2: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the unblocked form of the algorithm, calling Level 2 BLAS.

Here is the call graph for this function:

◆ la_zlauum()

pure subroutine, public la_lapack_solve_tri_comp::la_zlauum ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

ZLAUUM: computes the product U * U**H or L**H * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.

Here is the call graph for this function:

◆ la_ztbcon()

pure subroutine, public la_lapack_solve_tri_comp::la_ztbcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
complex(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
real(dp), intent(out) rcond,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZTBCON: estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ztbrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_ztbrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
complex(dp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(dp), dimension(*), intent(out) ferr,
real(dp), dimension(*), intent(out) berr,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZTBRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by ZTBTRS or some other means before entering this routine. ZTBRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ztbtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_ztbtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) kd,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(ldab,*), intent(in) ab,
integer(ilp), intent(in) ldab,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

ZTBTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_ztftri()

pure subroutine, public la_lapack_solve_tri_comp::la_ztftri ( character, intent(in) transr,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(dp), dimension(0:*), intent(inout) a,
integer(ilp), intent(out) info )

ZTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ztpcon()

pure subroutine, public la_lapack_solve_tri_comp::la_ztpcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(in) ap,
real(dp), intent(out) rcond,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZTPCON: estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ztprfs()

pure subroutine, public la_lapack_solve_tri_comp::la_ztprfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(*), intent(in) ap,
complex(dp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
complex(dp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(dp), dimension(*), intent(out) ferr,
real(dp), dimension(*), intent(out) berr,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZTPRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by ZTPTRS or some other means before entering this routine. ZTPRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ztptri()

pure subroutine, public la_lapack_solve_tri_comp::la_ztptri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
integer(ilp), intent(out) info )

ZTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

Here is the call graph for this function:

◆ la_ztptrs()

pure subroutine, public la_lapack_solve_tri_comp::la_ztptrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(*), intent(in) ap,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

ZTPTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function:

◆ la_ztrcon()

pure subroutine, public la_lapack_solve_tri_comp::la_ztrcon ( character, intent(in) norm,
character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(dp), intent(out) rcond,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZTRCON: estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

Here is the call graph for this function:

◆ la_ztrrfs()

pure subroutine, public la_lapack_solve_tri_comp::la_ztrrfs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(ldb,*), intent(in) b,
integer(ilp), intent(in) ldb,
complex(dp), dimension(ldx,*), intent(in) x,
integer(ilp), intent(in) ldx,
real(dp), dimension(*), intent(out) ferr,
real(dp), dimension(*), intent(out) berr,
complex(dp), dimension(*), intent(out) work,
real(dp), dimension(*), intent(out) rwork,
integer(ilp), intent(out) info )

ZTRRFS: provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by ZTRTRS or some other means before entering this routine. ZTRRFS does not do iterative refinement because doing so cannot improve the backward error.

Here is the call graph for this function:

◆ la_ztrti2()

pure subroutine, public la_lapack_solve_tri_comp::la_ztrti2 ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

ZTRTI2: computes the inverse of a complex upper or lower triangular matrix. This is the Level 2 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ztrtri()

pure subroutine, public la_lapack_solve_tri_comp::la_ztrtri ( character, intent(in) uplo,
character, intent(in) diag,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(out) info )

ZTRTRI: computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.

Here is the call graph for this function:

◆ la_ztrtrs()

pure subroutine, public la_lapack_solve_tri_comp::la_ztrtrs ( character, intent(in) uplo,
character, intent(in) trans,
character, intent(in) diag,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

ZTRTRS: solves a triangular system of the form A * X = B, A**T * X = B, or A**H * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.

Here is the call graph for this function: