Cholesky components: factorization, solve, inverse, condition, equilibration. More...
Functions/Subroutines | |
| pure subroutine, public | la_slaqsp (uplo, n, ap, s, scond, amax, equed) |
| SLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_dlaqsp (uplo, n, ap, s, scond, amax, equed) |
| DLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_qlaqsp (uplo, n, ap, s, scond, amax, equed) |
| QLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_spbequ (uplo, n, kd, ab, ldab, s, scond, amax, info) |
| SPBEQU: computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_dpbequ (uplo, n, kd, ab, ldab, s, scond, amax, info) |
| DPBEQU: computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_qpbequ (uplo, n, kd, ab, ldab, s, scond, amax, info) |
| QPBEQU: computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_spbtf2 (uplo, n, kd, ab, ldab, info) |
| SPBTF2: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix, U**T is the transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_dpbtf2 (uplo, n, kd, ab, ldab, info) |
| DPBTF2: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix, U**T is the transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_qpbtf2 (uplo, n, kd, ab, ldab, info) |
| QPBTF2: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix, U**T is the transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_spbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| SPBTRS: solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPBTRF. | |
| pure subroutine, public | la_dpbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| DPBTRS: solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPBTRF. | |
| pure subroutine, public | la_qpbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| QPBTRS: solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPBTRF. | |
| pure subroutine, public | la_spoequ (n, a, lda, s, scond, amax, info) |
| SPOEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_dpoequ (n, a, lda, s, scond, amax, info) |
| DPOEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_qpoequ (n, a, lda, s, scond, amax, info) |
| QPOEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_spoequb (n, a, lda, s, scond, amax, info) |
| SPOEQUB: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from SPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_dpoequb (n, a, lda, s, scond, amax, info) |
| DPOEQUB: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from DPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_qpoequb (n, a, lda, s, scond, amax, info) |
| QPOEQUB: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from QPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_spotrs (uplo, n, nrhs, a, lda, b, ldb, info) |
| SPOTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF. | |
| pure subroutine, public | la_dpotrs (uplo, n, nrhs, a, lda, b, ldb, info) |
| DPOTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF. | |
| pure subroutine, public | la_qpotrs (uplo, n, nrhs, a, lda, b, ldb, info) |
| QPOTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPOTRF. | |
| pure subroutine, public | la_sppequ (uplo, n, ap, s, scond, amax, info) |
| SPPEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_dppequ (uplo, n, ap, s, scond, amax, info) |
| DPPEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_qppequ (uplo, n, ap, s, scond, amax, info) |
| QPPEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_spptrf (uplo, n, ap, info) |
| SPPTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_dpptrf (uplo, n, ap, info) |
| DPPTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_qpptrf (uplo, n, ap, info) |
| QPPTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_spptrs (uplo, n, nrhs, ap, b, ldb, info) |
| SPPTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPPTRF. | |
| pure subroutine, public | la_dpptrs (uplo, n, nrhs, ap, b, ldb, info) |
| DPPTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPPTRF. | |
| pure subroutine, public | la_qpptrs (uplo, n, nrhs, ap, b, ldb, info) |
| QPPTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPPTRF. | |
| pure subroutine, public | la_sptcon (n, d, e, anorm, rcond, work, info) |
| SPTCON: computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = L*D*L**T or A = U**T*D*U computed by SPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_dptcon (n, d, e, anorm, rcond, work, info) |
| DPTCON: computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = L*D*L**T or A = U**T*D*U computed by DPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_qptcon (n, d, e, anorm, rcond, work, info) |
| QPTCON: computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = L*D*L**T or A = U**T*D*U computed by QPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_spttrf (n, d, e, info) |
| SPTTRF: computes the L*D*L**T factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**T*D*U. | |
| pure subroutine, public | la_dpttrf (n, d, e, info) |
| DPTTRF: computes the L*D*L**T factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**T*D*U. | |
| pure subroutine, public | la_qpttrf (n, d, e, info) |
| QPTTRF: computes the L*D*L**T factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**T*D*U. | |
| pure subroutine, public | la_sptts2 (n, nrhs, d, e, b, ldb) |
| SPTTS2: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by SPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_dptts2 (n, nrhs, d, e, b, ldb) |
| DPTTS2: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by DPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_qptts2 (n, nrhs, d, e, b, ldb) |
| QPTTS2: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by QPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices. | |
| real(sp) function, public | la_sla_porcond (uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork) |
| SLA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| real(dp) function, public | la_dla_porcond (uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork) |
| DLA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| real(qp) function, public | la_qla_porcond (uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork) |
| QLA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_spbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) |
| SPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_dpbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) |
| DPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_qpbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) |
| QPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_spbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| SPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dpbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| DPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_qpbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| QPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_spftrs (transr, uplo, n, nrhs, a, b, ldb, info) |
| SPFTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPFTRF. | |
| pure subroutine, public | la_dpftrs (transr, uplo, n, nrhs, a, b, ldb, info) |
| DPFTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPFTRF. | |
| pure subroutine, public | la_qpftrs (transr, uplo, n, nrhs, a, b, ldb, info) |
| QPFTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPFTRF. | |
| pure subroutine, public | la_spocon (uplo, n, a, lda, anorm, rcond, work, iwork, info) |
| SPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_dpocon (uplo, n, a, lda, anorm, rcond, work, iwork, info) |
| DPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_qpocon (uplo, n, a, lda, anorm, rcond, work, iwork, info) |
| QPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_sporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| SPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| DPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_qporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| QPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_spotf2 (uplo, n, a, lda, info) |
| SPOTF2: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_dpotf2 (uplo, n, a, lda, info) |
| DPOTF2: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_qpotf2 (uplo, n, a, lda, info) |
| QPOTF2: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure recursive subroutine, public | la_spotrf2 (uplo, n, a, lda, info) |
| SPOTRF2: computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22. | |
| pure recursive subroutine, public | la_dpotrf2 (uplo, n, a, lda, info) |
| DPOTRF2: computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22. | |
| pure recursive subroutine, public | la_qpotrf2 (uplo, n, a, lda, info) |
| QPOTRF2: computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22. | |
| pure subroutine, public | la_spotri (uplo, n, a, lda, info) |
| SPOTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF. | |
| pure subroutine, public | la_dpotri (uplo, n, a, lda, info) |
| DPOTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF. | |
| pure subroutine, public | la_qpotri (uplo, n, a, lda, info) |
| QPOTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPOTRF. | |
| pure subroutine, public | la_sppcon (uplo, n, ap, anorm, rcond, work, iwork, info) |
| SPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_dppcon (uplo, n, ap, anorm, rcond, work, iwork, info) |
| DPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_qppcon (uplo, n, ap, anorm, rcond, work, iwork, info) |
| QPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_spprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| SPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dpprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| DPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_qpprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| QPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_spptri (uplo, n, ap, info) |
| SPPTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPPTRF. | |
| pure subroutine, public | la_dpptri (uplo, n, ap, info) |
| DPPTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPPTRF. | |
| pure subroutine, public | la_qpptri (uplo, n, ap, info) |
| QPPTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPPTRF. | |
| pure subroutine, public | la_spstf2 (uplo, n, a, lda, piv, rank, tol, work, info) |
| SPSTF2: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS. | |
| pure subroutine, public | la_dpstf2 (uplo, n, a, lda, piv, rank, tol, work, info) |
| DPSTF2: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS. | |
| pure subroutine, public | la_qpstf2 (uplo, n, a, lda, piv, rank, tol, work, info) |
| QPSTF2: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS. | |
| pure subroutine, public | la_spstrf (uplo, n, a, lda, piv, rank, tol, work, info) |
| SPSTRF: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS. | |
| pure subroutine, public | la_dpstrf (uplo, n, a, lda, piv, rank, tol, work, info) |
| DPSTRF: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS. | |
| pure subroutine, public | la_qpstrf (uplo, n, a, lda, piv, rank, tol, work, info) |
| QPSTRF: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS. | |
| pure subroutine, public | la_spttrs (n, nrhs, d, e, b, ldb, info) |
| SPTTRS: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by SPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_dpttrs (n, nrhs, d, e, b, ldb, info) |
| DPTTRS: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by DPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_qpttrs (n, nrhs, d, e, b, ldb, info) |
| QPTTRS: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by QPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_spbtrf (uplo, n, kd, ab, ldab, info) |
| SPBTRF: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_dpbtrf (uplo, n, kd, ab, ldab, info) |
| DPBTRF: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_qpbtrf (uplo, n, kd, ab, ldab, info) |
| QPBTRF: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_spftri (transr, uplo, n, a, info) |
| SPFTRI: computes the inverse of a real (symmetric) positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPFTRF. | |
| pure subroutine, public | la_dpftri (transr, uplo, n, a, info) |
| DPFTRI: computes the inverse of a (real) symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPFTRF. | |
| pure subroutine, public | la_qpftri (transr, uplo, n, a, info) |
| QPFTRI: computes the inverse of a (real) symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPFTRF. | |
| pure subroutine, public | la_spotrf (uplo, n, a, lda, info) |
| SPOTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_dpotrf (uplo, n, a, lda, info) |
| DPOTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_qpotrf (uplo, n, a, lda, info) |
| QPOTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_sptrfs (n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) |
| SPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dptrfs (n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) |
| DPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_qptrfs (n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) |
| QPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| real(sp) function, public | la_sla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work) |
| SLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| real(dp) function, public | la_dla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work) |
| DLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| real(qp) function, public | la_qla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work) |
| QLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_spftrf (transr, uplo, n, a, info) |
| SPFTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_dpftrf (transr, uplo, n, a, info) |
| DPFTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_qpftrf (transr, uplo, n, a, info) |
| QPFTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| real(sp) function, public | la_cla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work) |
| CLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| real(dp) function, public | la_zla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work) |
| ZLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| real(qp) function, public | la_wla_porpvgrw (uplo, ncols, a, lda, af, ldaf, work) |
| WLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_claqhb (uplo, n, kd, ab, ldab, s, scond, amax, equed) |
| CLAQHB: equilibrates an Hermitian band matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_zlaqhb (uplo, n, kd, ab, ldab, s, scond, amax, equed) |
| ZLAQHB: equilibrates a Hermitian band matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_wlaqhb (uplo, n, kd, ab, ldab, s, scond, amax, equed) |
| WLAQHB: equilibrates a Hermitian band matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_claqhe (uplo, n, a, lda, s, scond, amax, equed) |
| CLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_zlaqhe (uplo, n, a, lda, s, scond, amax, equed) |
| ZLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_wlaqhe (uplo, n, a, lda, s, scond, amax, equed) |
| WLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_claqhp (uplo, n, ap, s, scond, amax, equed) |
| CLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_zlaqhp (uplo, n, ap, s, scond, amax, equed) |
| ZLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_wlaqhp (uplo, n, ap, s, scond, amax, equed) |
| WLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_claqsp (uplo, n, ap, s, scond, amax, equed) |
| CLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_zlaqsp (uplo, n, ap, s, scond, amax, equed) |
| ZLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_wlaqsp (uplo, n, ap, s, scond, amax, equed) |
| WLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S. | |
| pure subroutine, public | la_cpbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) |
| CPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_zpbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) |
| ZPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_wpbcon (uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) |
| WPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_cpbequ (uplo, n, kd, ab, ldab, s, scond, amax, info) |
| CPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_zpbequ (uplo, n, kd, ab, ldab, s, scond, amax, info) |
| ZPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_wpbequ (uplo, n, kd, ab, ldab, s, scond, amax, info) |
| WPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_cpbtf2 (uplo, n, kd, ab, ldab, info) |
| CPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_zpbtf2 (uplo, n, kd, ab, ldab, info) |
| ZPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_wpbtf2 (uplo, n, kd, ab, ldab, info) |
| WPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_cpbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| CPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPBTRF. | |
| pure subroutine, public | la_zpbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| ZPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H *U or A = L*L**H computed by ZPBTRF. | |
| pure subroutine, public | la_wpbtrs (uplo, n, kd, nrhs, ab, ldab, b, ldb, info) |
| WPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H *U or A = L*L**H computed by WPBTRF. | |
| pure subroutine, public | la_cpocon (uplo, n, a, lda, anorm, rcond, work, rwork, info) |
| CPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_zpocon (uplo, n, a, lda, anorm, rcond, work, rwork, info) |
| ZPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_wpocon (uplo, n, a, lda, anorm, rcond, work, rwork, info) |
| WPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_cpoequ (n, a, lda, s, scond, amax, info) |
| CPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_zpoequ (n, a, lda, s, scond, amax, info) |
| ZPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_wpoequ (n, a, lda, s, scond, amax, info) |
| WPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_cpoequb (n, a, lda, s, scond, amax, info) |
| CPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_zpoequb (n, a, lda, s, scond, amax, info) |
| ZPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from ZPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_wpoequb (n, a, lda, s, scond, amax, info) |
| WPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from WPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_cpotf2 (uplo, n, a, lda, info) |
| CPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_zpotf2 (uplo, n, a, lda, info) |
| ZPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_wpotf2 (uplo, n, a, lda, info) |
| WPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure recursive subroutine, public | la_cpotrf2 (uplo, n, a, lda, info) |
| CPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22. | |
| pure recursive subroutine, public | la_zpotrf2 (uplo, n, a, lda, info) |
| ZPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22. | |
| pure recursive subroutine, public | la_wpotrf2 (uplo, n, a, lda, info) |
| WPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22. | |
| pure subroutine, public | la_cpotrs (uplo, n, nrhs, a, lda, b, ldb, info) |
| CPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF. | |
| pure subroutine, public | la_zpotrs (uplo, n, nrhs, a, lda, b, ldb, info) |
| ZPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H * U or A = L * L**H computed by ZPOTRF. | |
| pure subroutine, public | la_wpotrs (uplo, n, nrhs, a, lda, b, ldb, info) |
| WPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H * U or A = L * L**H computed by WPOTRF. | |
| pure subroutine, public | la_cppcon (uplo, n, ap, anorm, rcond, work, rwork, info) |
| CPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_zppcon (uplo, n, ap, anorm, rcond, work, rwork, info) |
| ZPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_wppcon (uplo, n, ap, anorm, rcond, work, rwork, info) |
| WPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_cppequ (uplo, n, ap, s, scond, amax, info) |
| CPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_zppequ (uplo, n, ap, s, scond, amax, info) |
| ZPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_wppequ (uplo, n, ap, s, scond, amax, info) |
| WPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. | |
| pure subroutine, public | la_cpptrf (uplo, n, ap, info) |
| CPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_zpptrf (uplo, n, ap, info) |
| ZPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_wpptrf (uplo, n, ap, info) |
| WPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_cpptrs (uplo, n, nrhs, ap, b, ldb, info) |
| CPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF. | |
| pure subroutine, public | la_zpptrs (uplo, n, nrhs, ap, b, ldb, info) |
| ZPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H * U or A = L * L**H computed by ZPPTRF. | |
| pure subroutine, public | la_wpptrs (uplo, n, nrhs, ap, b, ldb, info) |
| WPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H * U or A = L * L**H computed by WPPTRF. | |
| pure subroutine, public | la_cpstf2 (uplo, n, a, lda, piv, rank, tol, work, info) |
| CPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS. | |
| pure subroutine, public | la_zpstf2 (uplo, n, a, lda, piv, rank, tol, work, info) |
| ZPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS. | |
| pure subroutine, public | la_wpstf2 (uplo, n, a, lda, piv, rank, tol, work, info) |
| WPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS. | |
| pure subroutine, public | la_cpstrf (uplo, n, a, lda, piv, rank, tol, work, info) |
| CPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS. | |
| pure subroutine, public | la_zpstrf (uplo, n, a, lda, piv, rank, tol, work, info) |
| ZPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS. | |
| pure subroutine, public | la_wpstrf (uplo, n, a, lda, piv, rank, tol, work, info) |
| WPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS. | |
| pure subroutine, public | la_cptcon (n, d, e, anorm, rcond, rwork, info) |
| CPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_zptcon (n, d, e, anorm, rcond, rwork, info) |
| ZPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by ZPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_wptcon (n, d, e, anorm, rcond, rwork, info) |
| WPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by WPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_cpttrf (n, d, e, info) |
| CPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U. | |
| pure subroutine, public | la_zpttrf (n, d, e, info) |
| ZPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U. | |
| pure subroutine, public | la_wpttrf (n, d, e, info) |
| WPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U. | |
| pure subroutine, public | la_cptts2 (iuplo, n, nrhs, d, e, b, ldb) |
| CPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_zptts2 (iuplo, n, nrhs, d, e, b, ldb) |
| ZPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H *D*U or A = L*D*L**H computed by ZPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_wptts2 (iuplo, n, nrhs, d, e, b, ldb) |
| WPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H *D*U or A = L*D*L**H computed by WPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_cpbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zpbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_wpbrfs (uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_cpbtrf (uplo, n, kd, ab, ldab, info) |
| CPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_zpbtrf (uplo, n, kd, ab, ldab, info) |
| ZPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_wpbtrf (uplo, n, kd, ab, ldab, info) |
| WPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. | |
| pure subroutine, public | la_cpftrs (transr, uplo, n, nrhs, a, b, ldb, info) |
| CPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPFTRF. | |
| pure subroutine, public | la_zpftrs (transr, uplo, n, nrhs, a, b, ldb, info) |
| ZPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPFTRF. | |
| pure subroutine, public | la_wpftrs (transr, uplo, n, nrhs, a, b, ldb, info) |
| WPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPFTRF. | |
| pure subroutine, public | la_cporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_wporfs (uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_cpotrf (uplo, n, a, lda, info) |
| CPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_zpotrf (uplo, n, a, lda, info) |
| ZPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_wpotrf (uplo, n, a, lda, info) |
| WPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_cpotri (uplo, n, a, lda, info) |
| CPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF. | |
| pure subroutine, public | la_zpotri (uplo, n, a, lda, info) |
| ZPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPOTRF. | |
| pure subroutine, public | la_wpotri (uplo, n, a, lda, info) |
| WPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPOTRF. | |
| pure subroutine, public | la_cpprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zpprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_wpprfs (uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_cpptri (uplo, n, ap, info) |
| CPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF. | |
| pure subroutine, public | la_zpptri (uplo, n, ap, info) |
| ZPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPPTRF. | |
| pure subroutine, public | la_wpptri (uplo, n, ap, info) |
| WPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPPTRF. | |
| pure subroutine, public | la_cpttrs (uplo, n, nrhs, d, e, b, ldb, info) |
| CPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_zpttrs (uplo, n, nrhs, d, e, b, ldb, info) |
| ZPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H D U or A = L*D*L**H computed by ZPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_wpttrs (uplo, n, nrhs, d, e, b, ldb, info) |
| WPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H D U or A = L*D*L**H computed by WPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices. | |
| pure subroutine, public | la_cpftrf (transr, uplo, n, a, info) |
| CPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_zpftrf (transr, uplo, n, a, info) |
| ZPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_wpftrf (transr, uplo, n, a, info) |
| WPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_cpftri (transr, uplo, n, a, info) |
| CPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPFTRF. | |
| pure subroutine, public | la_zpftri (transr, uplo, n, a, info) |
| ZPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPFTRF. | |
| pure subroutine, public | la_wpftri (transr, uplo, n, a, info) |
| WPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPFTRF. | |
| pure subroutine, public | la_cptrfs (uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zptrfs (uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_wptrfs (uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution. | |
Detailed Description
Cholesky components: factorization, solve, inverse, condition, equilibration.
Function/Subroutine Documentation
◆ la_cla_porpvgrw()
| real(sp) function, public la_lapack_solve_chol_comp::la_cla_porpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | ncols, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(sp), dimension(*), intent(out) | work ) |
CLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
◆ la_claqhb()
| pure subroutine, public la_lapack_solve_chol_comp::la_claqhb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(in) | scond, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
CLAQHB: equilibrates an Hermitian band matrix A using the scaling factors in the vector S.
◆ la_claqhe()
| pure subroutine, public la_lapack_solve_chol_comp::la_claqhe | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | s, | ||
| real(sp), intent(in) | scond, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
CLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S.
◆ la_claqhp()
| pure subroutine, public la_lapack_solve_chol_comp::la_claqhp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | ap, | ||
| real(sp), dimension(*), intent(in) | s, | ||
| real(sp), intent(in) | scond, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
CLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S.
◆ la_claqsp()
| pure subroutine, public la_lapack_solve_chol_comp::la_claqsp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | ap, | ||
| real(sp), dimension(*), intent(in) | s, | ||
| real(sp), intent(in) | scond, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
CLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.
◆ la_cpbcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpbcon | ( | character, intent(in) | uplo, |
| 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(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_cpbequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpbequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_cpbrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpbrfs | ( | character, intent(in) | uplo, |
| 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(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | 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 ) |
CPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.
◆ la_cpbtf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpbtf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
CPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_cpbtrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpbtrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
CPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_cpbtrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpbtrs | ( | character, intent(in) | uplo, |
| 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 ) |
CPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPBTRF.
◆ la_cpftrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpftrf | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
CPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_cpftri()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpftri | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
CPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPFTRF.
◆ la_cpftrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpftrs | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(0:*), intent(in) | a, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPFTRF.
◆ la_cpocon()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpocon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_cpoequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpoequ | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_cpoequb()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpoequb | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
◆ la_cporfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cporfs | ( | character, intent(in) | uplo, |
| 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(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | 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 ) |
CPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.
◆ la_cpotf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpotf2 | ( | 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 ) |
CPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_cpotrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpotrf | ( | 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 ) |
CPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_cpotrf2()
| pure recursive subroutine, public la_lapack_solve_chol_comp::la_cpotrf2 | ( | 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 ) |
CPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.
◆ la_cpotri()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpotri | ( | 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 ) |
CPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF.
◆ la_cpotrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpotrs | ( | character, intent(in) | uplo, |
| 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 ) |
CPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF.
◆ la_cppcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_cppcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_cppequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_cppequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_cpprfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpprfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| complex(sp), dimension(*), intent(in) | afp, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | 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 ) |
CPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.
◆ la_cpptrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
CPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_cpptri()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpptri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
CPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF.
◆ la_cpptrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpptrs | ( | character, intent(in) | uplo, |
| 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 ) |
CPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H*U or A = L*L**H computed by CPPTRF.
◆ la_cpstf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpstf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(sp), intent(in) | tol, | ||
| real(sp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
CPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.
◆ la_cpstrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpstrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(sp), intent(in) | tol, | ||
| real(sp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
CPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
◆ la_cptcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_cptcon | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(in) | d, | ||
| complex(sp), dimension(*), intent(in) | e, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_cptrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cptrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| complex(sp), dimension(*), intent(in) | e, | ||
| real(sp), dimension(*), intent(in) | df, | ||
| complex(sp), dimension(*), intent(in) | ef, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | 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 ) |
CPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
◆ la_cpttrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpttrf | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | d, | ||
| complex(sp), dimension(*), intent(inout) | e, | ||
| integer(ilp), intent(out) | info ) |
CPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U.
◆ la_cpttrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_cpttrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| complex(sp), dimension(*), intent(in) | e, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_cptts2()
| pure subroutine, public la_lapack_solve_chol_comp::la_cptts2 | ( | integer(ilp), intent(in) | iuplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| complex(sp), dimension(*), intent(in) | e, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
CPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_dla_porcond()
| real(dp) function, public la_lapack_solve_chol_comp::la_dla_porcond | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
DLA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.
◆ la_dla_porpvgrw()
| real(dp) function, public la_lapack_solve_chol_comp::la_dla_porpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | ncols, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(dp), dimension(*), intent(out) | work ) |
DLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
◆ la_dlaqsp()
| pure subroutine, public la_lapack_solve_chol_comp::la_dlaqsp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(inout) | ap, | ||
| real(dp), dimension(*), intent(in) | s, | ||
| real(dp), intent(in) | scond, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
DLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.
◆ la_dpbcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpbcon | ( | character, intent(in) | uplo, |
| 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(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_dpbequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpbequ | ( | character, intent(in) | uplo, |
| 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(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DPBEQU: computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_dpbrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpbrfs | ( | character, intent(in) | uplo, |
| 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(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | 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 ) |
DPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.
◆ la_dpbtf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpbtf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
DPBTF2: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix, U**T is the transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_dpbtrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpbtrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
DPBTRF: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_dpbtrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpbtrs | ( | character, intent(in) | uplo, |
| 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 ) |
DPBTRS: solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPBTRF.
◆ la_dpftrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpftrf | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
DPFTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_dpftri()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpftri | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
DPFTRI: computes the inverse of a (real) symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPFTRF.
◆ la_dpftrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpftrs | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(0:*), intent(in) | a, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DPFTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPFTRF.
◆ la_dpocon()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpocon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_dpoequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpoequ | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DPOEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_dpoequb()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpoequb | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DPOEQUB: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from DPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
◆ la_dporfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dporfs | ( | character, intent(in) | uplo, |
| 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(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | 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 ) |
DPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.
◆ la_dpotf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpotf2 | ( | 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 ) |
DPOTF2: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_dpotrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpotrf | ( | 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 ) |
DPOTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_dpotrf2()
| pure recursive subroutine, public la_lapack_solve_chol_comp::la_dpotrf2 | ( | 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 ) |
DPOTRF2: computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.
◆ la_dpotri()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpotri | ( | 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 ) |
DPOTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF.
◆ la_dpotrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpotrs | ( | character, intent(in) | uplo, |
| 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 ) |
DPOTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF.
◆ la_dppcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_dppcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_dppequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_dppequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DPPEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_dpprfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpprfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| real(dp), dimension(*), intent(in) | afp, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | 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 ) |
DPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.
◆ la_dpptrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
DPPTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_dpptri()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpptri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
DPPTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPPTRF.
◆ la_dpptrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpptrs | ( | character, intent(in) | uplo, |
| 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 ) |
DPPTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = U**T*U or A = L*L**T computed by DPPTRF.
◆ la_dpstf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpstf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(dp), intent(in) | tol, | ||
| real(dp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DPSTF2: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.
◆ la_dpstrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpstrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(dp), intent(in) | tol, | ||
| real(dp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DPSTRF: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
◆ la_dptcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_dptcon | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(in) | d, | ||
| real(dp), dimension(*), intent(in) | e, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DPTCON: computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = L*D*L**T or A = U**T*D*U computed by DPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_dptrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dptrfs | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| real(dp), dimension(*), intent(in) | e, | ||
| real(dp), dimension(*), intent(in) | df, | ||
| real(dp), dimension(*), intent(in) | ef, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | 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), intent(out) | info ) |
DPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
◆ la_dpttrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpttrf | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(inout) | d, | ||
| real(dp), dimension(*), intent(inout) | e, | ||
| integer(ilp), intent(out) | info ) |
DPTTRF: computes the L*D*L**T factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**T*D*U.
◆ la_dpttrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_dpttrs | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| real(dp), dimension(*), intent(in) | e, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DPTTRS: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by DPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_dptts2()
| pure subroutine, public la_lapack_solve_chol_comp::la_dptts2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| real(dp), dimension(*), intent(in) | e, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
DPTTS2: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by DPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_qla_porcond()
| real(qp) function, public la_lapack_solve_chol_comp::la_qla_porcond | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
QLA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.
◆ la_qla_porpvgrw()
| real(qp) function, public la_lapack_solve_chol_comp::la_qla_porpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | ncols, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(qp), dimension(*), intent(out) | work ) |
QLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
◆ la_qlaqsp()
| pure subroutine, public la_lapack_solve_chol_comp::la_qlaqsp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(in) | s, | ||
| real(qp), intent(in) | scond, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
QLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.
◆ la_qpbcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpbcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_qpbequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpbequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QPBEQU: computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_qpbrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpbrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.
◆ la_qpbtf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpbtf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
QPBTF2: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix, U**T is the transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_qpbtrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpbtrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
QPBTRF: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_qpbtrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpbtrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QPBTRS: solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPBTRF.
◆ la_qpftrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpftrf | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
QPFTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_qpftri()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpftri | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
QPFTRI: computes the inverse of a (real) symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPFTRF.
◆ la_qpftrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpftrs | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(0:*), intent(in) | a, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QPFTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPFTRF.
◆ la_qpocon()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpocon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_qpoequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpoequ | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QPOEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_qpoequb()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpoequb | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QPOEQUB: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from QPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
◆ la_qporfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qporfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.
◆ la_qpotf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpotf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
QPOTF2: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_qpotrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpotrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
QPOTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_qpotrf2()
| pure recursive subroutine, public la_lapack_solve_chol_comp::la_qpotrf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
QPOTRF2: computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.
◆ la_qpotri()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpotri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
QPOTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPOTRF.
◆ la_qpotrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpotrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QPOTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPOTRF.
◆ la_qppcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_qppcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_qppequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_qppequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QPPEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_qpprfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpprfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(in) | afp, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.
◆ la_qpptrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
QPPTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_qpptri()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpptri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
QPPTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPPTRF.
◆ la_qpptrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpptrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QPPTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = U**T*U or A = L*L**T computed by QPPTRF.
◆ la_qpstf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpstf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(qp), intent(in) | tol, | ||
| real(qp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QPSTF2: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.
◆ la_qpstrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpstrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(qp), intent(in) | tol, | ||
| real(qp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QPSTRF: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
◆ la_qptcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_qptcon | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | e, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QPTCON: computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = L*D*L**T or A = U**T*D*U computed by QPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_qptrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qptrfs | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | e, | ||
| real(qp), dimension(*), intent(in) | df, | ||
| real(qp), dimension(*), intent(in) | ef, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
◆ la_qpttrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpttrf | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | d, | ||
| real(qp), dimension(*), intent(inout) | e, | ||
| integer(ilp), intent(out) | info ) |
QPTTRF: computes the L*D*L**T factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**T*D*U.
◆ la_qpttrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_qpttrs | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | e, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QPTTRS: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by QPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_qptts2()
| pure subroutine, public la_lapack_solve_chol_comp::la_qptts2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | e, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
QPTTS2: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by QPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_sla_porcond()
| real(sp) function, public la_lapack_solve_chol_comp::la_sla_porcond | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
SLA_PORCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.
◆ la_sla_porpvgrw()
| real(sp) function, public la_lapack_solve_chol_comp::la_sla_porpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | ncols, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(sp), dimension(*), intent(out) | work ) |
SLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
◆ la_slaqsp()
| pure subroutine, public la_lapack_solve_chol_comp::la_slaqsp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(inout) | ap, | ||
| real(sp), dimension(*), intent(in) | s, | ||
| real(sp), intent(in) | scond, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
SLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.
◆ la_spbcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_spbcon | ( | character, intent(in) | uplo, |
| 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(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_spbequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_spbequ | ( | character, intent(in) | uplo, |
| 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(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SPBEQU: computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_spbrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spbrfs | ( | character, intent(in) | uplo, |
| 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(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | 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 ) |
SPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.
◆ la_spbtf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_spbtf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
SPBTF2: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix, U**T is the transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_spbtrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_spbtrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| real(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
SPBTRF: computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_spbtrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spbtrs | ( | character, intent(in) | uplo, |
| 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 ) |
SPBTRS: solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPBTRF.
◆ la_spftrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_spftrf | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
SPFTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_spftri()
| pure subroutine, public la_lapack_solve_chol_comp::la_spftri | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
SPFTRI: computes the inverse of a real (symmetric) positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPFTRF.
◆ la_spftrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spftrs | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(0:*), intent(in) | a, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SPFTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPFTRF.
◆ la_spocon()
| pure subroutine, public la_lapack_solve_chol_comp::la_spocon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_spoequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_spoequ | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SPOEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_spoequb()
| pure subroutine, public la_lapack_solve_chol_comp::la_spoequb | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SPOEQUB: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from SPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
◆ la_sporfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_sporfs | ( | character, intent(in) | uplo, |
| 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(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | 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 ) |
SPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.
◆ la_spotf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_spotf2 | ( | 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 ) |
SPOTF2: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U , if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_spotrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_spotrf | ( | 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 ) |
SPOTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_spotrf2()
| pure recursive subroutine, public la_lapack_solve_chol_comp::la_spotrf2 | ( | 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 ) |
SPOTRF2: computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.
◆ la_spotri()
| pure subroutine, public la_lapack_solve_chol_comp::la_spotri | ( | 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 ) |
SPOTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF.
◆ la_spotrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spotrs | ( | character, intent(in) | uplo, |
| 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 ) |
SPOTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF.
◆ la_sppcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_sppcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_sppequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_sppequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SPPEQU: computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_spprfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spprfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(in) | afp, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | 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 ) |
SPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.
◆ la_spptrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_spptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
SPPTRF: computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_spptri()
| pure subroutine, public la_lapack_solve_chol_comp::la_spptri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
SPPTRI: computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPPTRF.
◆ la_spptrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spptrs | ( | character, intent(in) | uplo, |
| 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 ) |
SPPTRS: solves a system of linear equations A*X = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = U**T*U or A = L*L**T computed by SPPTRF.
◆ la_spstf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_spstf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(sp), intent(in) | tol, | ||
| real(sp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SPSTF2: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.
◆ la_spstrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_spstrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(sp), intent(in) | tol, | ||
| real(sp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SPSTRF: computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form P**T * A * P = U**T * U , if UPLO = 'U', P**T * A * P = L * L**T, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
◆ la_sptcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_sptcon | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(in) | d, | ||
| real(sp), dimension(*), intent(in) | e, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SPTCON: computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = L*D*L**T or A = U**T*D*U computed by SPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_sptrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_sptrfs | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| real(sp), dimension(*), intent(in) | e, | ||
| real(sp), dimension(*), intent(in) | df, | ||
| real(sp), dimension(*), intent(in) | ef, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | 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), intent(out) | info ) |
SPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
◆ la_spttrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_spttrf | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | d, | ||
| real(sp), dimension(*), intent(inout) | e, | ||
| integer(ilp), intent(out) | info ) |
SPTTRF: computes the L*D*L**T factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**T*D*U.
◆ la_spttrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_spttrs | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| real(sp), dimension(*), intent(in) | e, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SPTTRS: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by SPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_sptts2()
| pure subroutine, public la_lapack_solve_chol_comp::la_sptts2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| real(sp), dimension(*), intent(in) | e, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
SPTTS2: solves a tridiagonal system of the form A * X = B using the L*D*L**T factorization of A computed by SPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_wla_porpvgrw()
| real(qp) function, public la_lapack_solve_chol_comp::la_wla_porpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | ncols, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(qp), dimension(*), intent(out) | work ) |
WLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
◆ la_wlaqhb()
| pure subroutine, public la_lapack_solve_chol_comp::la_wlaqhb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(in) | scond, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
WLAQHB: equilibrates a Hermitian band matrix A using the scaling factors in the vector S.
◆ la_wlaqhe()
| pure subroutine, public la_lapack_solve_chol_comp::la_wlaqhe | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | s, | ||
| real(qp), intent(in) | scond, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
WLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S.
◆ la_wlaqhp()
| pure subroutine, public la_lapack_solve_chol_comp::la_wlaqhp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(in) | s, | ||
| real(qp), intent(in) | scond, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
WLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S.
◆ la_wlaqsp()
| pure subroutine, public la_lapack_solve_chol_comp::la_wlaqsp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| real(qp), dimension(*), intent(in) | s, | ||
| real(qp), intent(in) | scond, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
WLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.
◆ la_wpbcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpbcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_wpbequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpbequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_wpbrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpbrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.
◆ la_wpbtf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpbtf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
WPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_wpbtrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpbtrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
WPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_wpbtrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpbtrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H *U or A = L*L**H computed by WPBTRF.
◆ la_wpftrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpftrf | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
WPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_wpftri()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpftri | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
WPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPFTRF.
◆ la_wpftrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpftrs | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(0:*), intent(in) | a, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPFTRF.
◆ la_wpocon()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpocon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_wpoequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpoequ | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_wpoequb()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpoequb | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from WPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
◆ la_wporfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wporfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.
◆ la_wpotf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpotf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
WPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_wpotrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpotrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
WPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_wpotrf2()
| pure recursive subroutine, public la_lapack_solve_chol_comp::la_wpotrf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
WPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.
◆ la_wpotri()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpotri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | info ) |
WPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPOTRF.
◆ la_wpotrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpotrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H * U or A = L * L**H computed by WPOTRF.
◆ la_wppcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_wppcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_wppequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_wppequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(out) | s, | ||
| real(qp), intent(out) | scond, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_wpprfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpprfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| complex(qp), dimension(*), intent(in) | afp, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.
◆ la_wpptrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
WPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_wpptri()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpptri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
WPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by WPPTRF.
◆ la_wpptrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpptrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(*), intent(in) | ap, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H * U or A = L * L**H computed by WPPTRF.
◆ la_wpstf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpstf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(qp), intent(in) | tol, | ||
| real(qp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
WPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.
◆ la_wpstrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpstrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(qp), intent(in) | tol, | ||
| real(qp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
WPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
◆ la_wptcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_wptcon | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | e, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by WPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_wptrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wptrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | e, | ||
| real(qp), dimension(*), intent(in) | df, | ||
| complex(qp), dimension(*), intent(in) | ef, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
◆ la_wpttrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpttrf | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | d, | ||
| complex(qp), dimension(*), intent(inout) | e, | ||
| integer(ilp), intent(out) | info ) |
WPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U.
◆ la_wpttrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_wpttrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | e, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H D U or A = L*D*L**H computed by WPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_wptts2()
| pure subroutine, public la_lapack_solve_chol_comp::la_wptts2 | ( | integer(ilp), intent(in) | iuplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | e, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
WPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H *D*U or A = L*D*L**H computed by WPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_zla_porpvgrw()
| real(dp) function, public la_lapack_solve_chol_comp::la_zla_porpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | ncols, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(dp), dimension(*), intent(out) | work ) |
ZLA_PORPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
◆ la_zlaqhb()
| pure subroutine, public la_lapack_solve_chol_comp::la_zlaqhb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(in) | scond, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
ZLAQHB: equilibrates a Hermitian band matrix A using the scaling factors in the vector S.
◆ la_zlaqhe()
| pure subroutine, public la_lapack_solve_chol_comp::la_zlaqhe | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | s, | ||
| real(dp), intent(in) | scond, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
ZLAQHE: equilibrates a Hermitian matrix A using the scaling factors in the vector S.
◆ la_zlaqhp()
| pure subroutine, public la_lapack_solve_chol_comp::la_zlaqhp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | ap, | ||
| real(dp), dimension(*), intent(in) | s, | ||
| real(dp), intent(in) | scond, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
ZLAQHP: equilibrates a Hermitian matrix A using the scaling factors in the vector S.
◆ la_zlaqsp()
| pure subroutine, public la_lapack_solve_chol_comp::la_zlaqsp | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | ap, | ||
| real(dp), dimension(*), intent(in) | s, | ||
| real(dp), intent(in) | scond, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
ZLAQSP: equilibrates a symmetric matrix A using the scaling factors in the vector S.
◆ la_zpbcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpbcon | ( | character, intent(in) | uplo, |
| 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(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZPBCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_zpbequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpbequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZPBEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_zpbrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpbrfs | ( | character, intent(in) | uplo, |
| 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(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | 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 ) |
ZPBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.
◆ la_zpbtf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpbtf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
ZPBTF2: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix, U**H is the conjugate transpose of U, and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_zpbtrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpbtrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kd, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), intent(out) | info ) |
ZPBTRF: computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_zpbtrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpbtrs | ( | character, intent(in) | uplo, |
| 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 ) |
ZPBTRS: solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U**H *U or A = L*L**H computed by ZPBTRF.
◆ la_zpftrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpftrf | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
ZPFTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_zpftri()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpftri | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(0:*), intent(inout) | a, | ||
| integer(ilp), intent(out) | info ) |
ZPFTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPFTRF.
◆ la_zpftrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpftrs | ( | character, intent(in) | transr, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(0:*), intent(in) | a, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZPFTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPFTRF.
◆ la_zpocon()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpocon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZPOCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_zpoequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpoequ | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZPOEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_zpoequb()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpoequb | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZPOEQUB: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from ZPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
◆ la_zporfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zporfs | ( | character, intent(in) | uplo, |
| 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(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | 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 ) |
ZPORFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.
◆ la_zpotf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpotf2 | ( | 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 ) |
ZPOTF2: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U , if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the unblocked version of the algorithm, calling Level 2 BLAS.
◆ la_zpotrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpotrf | ( | 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 ) |
ZPOTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
◆ la_zpotrf2()
| pure recursive subroutine, public la_lapack_solve_chol_comp::la_zpotrf2 | ( | 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 ) |
ZPOTRF2: computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.
◆ la_zpotri()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpotri | ( | 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 ) |
ZPOTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPOTRF.
◆ la_zpotrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpotrs | ( | character, intent(in) | uplo, |
| 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 ) |
ZPOTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A using the Cholesky factorization A = U**H * U or A = L * L**H computed by ZPOTRF.
◆ la_zppcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_zppcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZPPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_zppequ()
| pure subroutine, public la_lapack_solve_chol_comp::la_zppequ | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZPPEQU: computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
◆ la_zpprfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpprfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| complex(dp), dimension(*), intent(in) | afp, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | 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 ) |
ZPPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.
◆ la_zpptrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
ZPPTRF: computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
◆ la_zpptri()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpptri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), intent(out) | info ) |
ZPPTRI: computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by ZPPTRF.
◆ la_zpptrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpptrs | ( | character, intent(in) | uplo, |
| 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 ) |
ZPPTRS: solves a system of linear equations A*X = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = U**H * U or A = L * L**H computed by ZPPTRF.
◆ la_zpstf2()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpstf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(dp), intent(in) | tol, | ||
| real(dp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
ZPSTF2: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 2 BLAS.
◆ la_zpstrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpstrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(n), intent(out) | piv, | ||
| integer(ilp), intent(out) | rank, | ||
| real(dp), intent(in) | tol, | ||
| real(dp), dimension(2*n), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
ZPSTRF: computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form P**T * A * P = U**H * U , if UPLO = 'U', P**T * A * P = L * L**H, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
◆ la_zptcon()
| pure subroutine, public la_lapack_solve_chol_comp::la_zptcon | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(in) | d, | ||
| complex(dp), dimension(*), intent(in) | e, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZPTCON: computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = L*D*L**H or A = U**H*D*U computed by ZPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_zptrfs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zptrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| complex(dp), dimension(*), intent(in) | e, | ||
| real(dp), dimension(*), intent(in) | df, | ||
| complex(dp), dimension(*), intent(in) | ef, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | 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 ) |
ZPTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
◆ la_zpttrf()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpttrf | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(inout) | d, | ||
| complex(dp), dimension(*), intent(inout) | e, | ||
| integer(ilp), intent(out) | info ) |
ZPTTRF: computes the L*D*L**H factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = U**H *D*U.
◆ la_zpttrs()
| pure subroutine, public la_lapack_solve_chol_comp::la_zpttrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| complex(dp), dimension(*), intent(in) | e, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZPTTRS: solves a tridiagonal system of the form A * X = B using the factorization A = U**H D U or A = L*D*L**H computed by ZPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
◆ la_zptts2()
| pure subroutine, public la_lapack_solve_chol_comp::la_zptts2 | ( | integer(ilp), intent(in) | iuplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| complex(dp), dimension(*), intent(in) | e, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
ZPTTS2: solves a tridiagonal system of the form A * X = B using the factorization A = U**H *D*U or A = L*D*L**H computed by ZPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
