Modules
module	la_lapack_solve_tri_comp
	Triangular systems: solve, inverse, condition estimation, refinement.

Functions/Subroutines
pure subroutine, public	la_lapack_solve_tri_comp::la_slatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	SLATBS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_dlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	DLATBS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_qlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	QLATBS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT 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 QTBSV 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_slatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	SLATPS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_dlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	DLATPS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_qlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	QLATPS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT 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 QTPSV 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_slatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	SLATRS: solves one of the triangular systems A x = sb or A*Tx = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_dlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	DLATRS: solves one of the triangular systems A x = sb or A*T x = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_qlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	QLATRS: solves one of the triangular systems A x = sb or A*T x = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT 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 QTRSV 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_slauu2 (uplo, n, a, lda, info)
	SLAUU2: computes the product U * UT or LT * 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_lapack_solve_tri_comp::la_dlauu2 (uplo, n, a, lda, info)
	DLAUU2: computes the product U * UT or LT * 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_lapack_solve_tri_comp::la_qlauu2 (uplo, n, a, lda, info)
	QLAUU2: computes the product U * UT or LT * 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_lapack_solve_tri_comp::la_slauum (uplo, n, a, lda, info)
	SLAUUM: computes the product U * UT or LT * 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_lapack_solve_tri_comp::la_dlauum (uplo, n, a, lda, info)
	DLAUUM: computes the product U * UT or LT * 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_lapack_solve_tri_comp::la_qlauum (uplo, n, a, lda, info)
	QLAUUM: computes the product U * UT or LT * 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info)
	QTBRFS: 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 QTBTRS or some other means before entering this routine. QTBRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
	QTBTRS: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info)
	QTPRFS: 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 QTPTRS or some other means before entering this routine. QTPRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtptri (uplo, diag, n, ap, info)
	QTPTRI: computes the inverse of a real upper or lower triangular matrix A stored in packed format.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
	QTPTRS: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtrrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info)
	QTRRFS: 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 QTRTRS or some other means before entering this routine. QTRRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtrti2 (uplo, diag, n, a, lda, info)
	QTRTI2: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtrtri (uplo, diag, n, a, lda, info)
	QTRTRI: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtrtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
	QTRTRS: 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.

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::la_qtbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info)
	QTBCON: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_qtftri (transr, uplo, diag, n, a, info)
	QTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::la_qtpcon (norm, uplo, diag, n, ap, rcond, work, iwork, info)
	QTPCON: 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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::la_qtrcon (norm, uplo, diag, n, a, lda, rcond, work, iwork, info)
	QTRCON: 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_lapack_solve_tri_comp::la_clatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	CLATBS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_zlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	ZLATBS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_wlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
	WLATBS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT 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 WTBSV 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_clatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	CLATPS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, AH 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_zlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	ZLATPS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, AH 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_wlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
	WLATPS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, AH 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 WTPSV 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_clatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	CLATRS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, AH 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_zlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	ZLATRS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, AH 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_wlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
	WLATRS: solves one of the triangular systems A * x = sb, AT x = sb, or AH x = sb, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, AH 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 WTRSV 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 Ax = 0 is returned.

pure subroutine, public	la_lapack_solve_tri_comp::la_clauu2 (uplo, n, a, lda, info)
	CLAUU2: computes the product U * UH or LH * 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_lapack_solve_tri_comp::la_zlauu2 (uplo, n, a, lda, info)
	ZLAUU2: computes the product U * UH or LH * 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_lapack_solve_tri_comp::la_wlauu2 (uplo, n, a, lda, info)
	WLAUU2: computes the product U * UH or LH * 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_lapack_solve_tri_comp::la_clauum (uplo, n, a, lda, info)
	CLAUUM: computes the product U * UH or LH * 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_lapack_solve_tri_comp::la_zlauum (uplo, n, a, lda, info)
	ZLAUUM: computes the product U * UH or LH * 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_lapack_solve_tri_comp::la_wlauum (uplo, n, a, lda, info)
	WLAUUM: computes the product U * UH or LH * 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtbrfs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	WTBRFS: 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 WTBTRS or some other means before entering this routine. WTBRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtbtrs (uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info)
	WTBTRS: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtprfs (uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	WTPRFS: 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 WTPTRS or some other means before entering this routine. WTPRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtptri (uplo, diag, n, ap, info)
	WTPTRI: computes the inverse of a complex upper or lower triangular matrix A stored in packed format.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtptrs (uplo, trans, diag, n, nrhs, ap, b, ldb, info)
	WTPTRS: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtrrfs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	WTRRFS: 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 WTRTRS or some other means before entering this routine. WTRRFS does not do iterative refinement because doing so cannot improve the backward error.

pure subroutine, public	la_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtrti2 (uplo, diag, n, a, lda, info)
	WTRTI2: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtrtri (uplo, diag, n, a, lda, info)
	WTRTRI: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtrtrs (uplo, trans, diag, n, nrhs, a, lda, b, ldb, info)
	WTRTRS: 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.

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::la_wtbcon (norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info)
	WTBCON: 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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::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_lapack_solve_tri_comp::la_wtftri (transr, uplo, diag, n, a, info)
	WTFTRI: computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::la_wtpcon (norm, uplo, diag, n, ap, rcond, work, rwork, info)
	WTPCON: 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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::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)) ).

subroutine, public	la_lapack_solve_tri_comp::la_wtrcon (norm, uplo, diag, n, a, lda, rcond, work, rwork, info)
	WTRCON: 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)) ).

Modules

Functions/Subroutines