|
| pure subroutine, public | la_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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_lapack_solve_chol_comp::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.
|
| |
1.13.2