la_lapack_solve_chol Module Reference

Cholesky drivers: positive definite, packed, banded and tridiagonal systems. More...

Functions/Subroutines
pure subroutine, public	la_sppsv (uplo, n, nrhs, ap, b, ldb, info)
	SPPSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_dppsv (uplo, n, nrhs, ap, b, ldb, info)
	DPPSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_qppsv (uplo, n, nrhs, ap, b, ldb, info)
	QPPSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
subroutine, public	la_sppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	SPPSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_dppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	DPPSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_qppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	QPPSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_sptsv (n, nrhs, d, e, b, ldb, info)
	SPTSV: computes the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**T, and the factored form of A is then used to solve the system of equations.
pure subroutine, public	la_dptsv (n, nrhs, d, e, b, ldb, info)
	DPTSV: computes the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**T, and the factored form of A is then used to solve the system of equations.
pure subroutine, public	la_qptsv (n, nrhs, d, e, b, ldb, info)
	QPTSV: computes the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**T, and the factored form of A is then used to solve the system of equations.
pure subroutine, public	la_sptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info)
	SPTSVX: uses the factorization A = L*D*L**T to compute the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_dptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info)
	DPTSVX: uses the factorization A = L*D*L**T to compute the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_qptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info)
	QPTSVX: uses the factorization A = L*D*L**T to compute the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_dsposv (uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, iter, info)
	DSPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. DSPOSV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with DOUBLE PRECISION normwise backward error quality (see below). If the approach fails the method switches to a DOUBLE PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over DOUBLE PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
subroutine, public	la_qdposv (uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, iter, info)
	QDPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. QDPOSV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with QUAD PRECISION normwise backward error quality (see below). If the approach fails the method switches to a QUAD PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over QUAD PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
pure subroutine, public	la_spbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	SPBSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_dpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	DPBSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_qpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	QPBSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
subroutine, public	la_spbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	SPBSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_dpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	DPBSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_qpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	QPBSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_sposv (uplo, n, nrhs, a, lda, b, ldb, info)
	SPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_dposv (uplo, n, nrhs, a, lda, b, ldb, info)
	DPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_qposv (uplo, n, nrhs, a, lda, b, ldb, info)
	QPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
subroutine, public	la_sposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	SPOSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_dposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	DPOSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_qposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info)
	QPOSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_cppsv (uplo, n, nrhs, ap, b, ldb, info)
	CPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_zppsv (uplo, n, nrhs, ap, b, ldb, info)
	ZPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_wppsv (uplo, n, nrhs, ap, b, ldb, info)
	WPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
subroutine, public	la_cppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPPSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_zppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZPPSVX: uses the Cholesky factorization A = U**H * U or A = L * L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_wppsvx (fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WPPSVX: uses the Cholesky factorization A = U**H * U or A = L * L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_zcposv (uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, rwork, iter, info)
	ZCPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. ZCPOSV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
subroutine, public	la_wzposv (uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, rwork, iter, info)
	WZPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. WZPOSV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.
pure subroutine, public	la_cpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	CPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_zpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	ZPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_wpbsv (uplo, n, kd, nrhs, ab, ldab, b, ldb, info)
	WPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
subroutine, public	la_cpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_zpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_wpbsvx (fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_cposv (uplo, n, nrhs, a, lda, b, ldb, info)
	CPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_zposv (uplo, n, nrhs, a, lda, b, ldb, info)
	ZPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
pure subroutine, public	la_wposv (uplo, n, nrhs, a, lda, b, ldb, info)
	WPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
subroutine, public	la_cposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_zposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
subroutine, public	la_wposvx (fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_cptsv (n, nrhs, d, e, b, ldb, info)
	CPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.
pure subroutine, public	la_zptsv (n, nrhs, d, e, b, ldb, info)
	ZPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.
pure subroutine, public	la_wptsv (n, nrhs, d, e, b, ldb, info)
	WPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.
pure subroutine, public	la_cptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	CPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_zptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	ZPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
pure subroutine, public	la_wptsvx (fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
	WPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Detailed Description

Cholesky drivers: positive definite, packed, banded and tridiagonal systems.

Function/Subroutine Documentation

la_cpbsv()

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

CPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_cpbsvx()

subroutine, public la_lapack_solve_chol::la_cpbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(sp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

CPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_cposv()

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

CPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_cposvx()

subroutine, public la_lapack_solve_chol::la_cposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

CPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_cppsv()

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

CPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_cppsvx()

subroutine, public la_lapack_solve_chol::la_cppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(sp), dimension(*), intent(inout)	ap,
		complex(sp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

CPPSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_cptsv()

pure subroutine, public la_lapack_solve_chol::la_cptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(inout)	d,
		complex(sp), dimension(*), intent(inout)	e,
		complex(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

CPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

la_cptsvx()

pure subroutine, public la_lapack_solve_chol::la_cptsvx	(	character, intent(in)	fact,
		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(inout)	df,
		complex(sp), dimension(*), intent(inout)	ef,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

CPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_dpbsv()

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

DPBSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_dpbsvx()

subroutine, public la_lapack_solve_chol::la_dpbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(dp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	s,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

DPBSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_dposv()

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

DPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_dposvx()

subroutine, public la_lapack_solve_chol::la_dposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	s,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

DPOSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_dppsv()

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

DPPSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_dppsvx()

subroutine, public la_lapack_solve_chol::la_dppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(*), intent(inout)	ap,
		real(dp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	s,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

DPPSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_dptsv()

pure subroutine, public la_lapack_solve_chol::la_dptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(*), intent(inout)	d,
		real(dp), dimension(*), intent(inout)	e,
		real(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

DPTSV: computes the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**T, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

la_dptsvx()

pure subroutine, public la_lapack_solve_chol::la_dptsvx	(	character, intent(in)	fact,
		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(inout)	df,
		real(dp), dimension(*), intent(inout)	ef,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		real(dp), dimension(*), intent(out)	ferr,
		real(dp), dimension(*), intent(out)	berr,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

DPTSVX: uses the factorization A = L*D*L**T to compute the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_dsposv()

subroutine, public la_lapack_solve_chol::la_dsposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), dimension(n,*), intent(out)	work,
		real(sp), dimension(*), intent(out)	swork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

DSPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. DSPOSV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with DOUBLE PRECISION normwise backward error quality (see below). If the approach fails the method switches to a DOUBLE PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over DOUBLE PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

la_qdposv()

subroutine, public la_lapack_solve_chol::la_qdposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), dimension(n,*), intent(out)	work,
		real(dp), dimension(*), intent(out)	swork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

QDPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. QDPOSV first attempts to factorize the matrix in SINGLE PRECISION and use this factorization within an iterative refinement procedure to produce a solution with QUAD PRECISION normwise backward error quality (see below). If the approach fails the method switches to a QUAD PRECISION factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio SINGLE PRECISION performance over QUAD PRECISION performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

la_qpbsv()

pure subroutine, public la_lapack_solve_chol::la_qpbsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QPBSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_qpbsvx()

subroutine, public la_lapack_solve_chol::la_qpbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(qp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	s,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

QPBSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_qposv()

pure subroutine, public la_lapack_solve_chol::la_qposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_qposvx()

subroutine, public la_lapack_solve_chol::la_qposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	s,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

QPOSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_qppsv()

pure subroutine, public la_lapack_solve_chol::la_qppsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(*), intent(inout)	ap,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QPPSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_qppsvx()

subroutine, public la_lapack_solve_chol::la_qppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(*), intent(inout)	ap,
		real(qp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	s,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

QPPSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_qptsv()

pure subroutine, public la_lapack_solve_chol::la_qptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(*), intent(inout)	d,
		real(qp), dimension(*), intent(inout)	e,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

QPTSV: computes the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**T, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

la_qptsvx()

pure subroutine, public la_lapack_solve_chol::la_qptsvx	(	character, intent(in)	fact,
		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(inout)	df,
		real(qp), dimension(*), intent(inout)	ef,
		real(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

QPTSVX: uses the factorization A = L*D*L**T to compute the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_spbsv()

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

SPBSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**T * U, if UPLO = 'U', or A = L * L**T, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_spbsvx()

subroutine, public la_lapack_solve_chol::la_spbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

SPBSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_sposv()

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

SPOSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_sposvx()

subroutine, public la_lapack_solve_chol::la_sposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

SPOSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_sppsv()

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

SPPSV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_sppsvx()

subroutine, public la_lapack_solve_chol::la_sppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(inout)	ap,
		real(sp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(sp), dimension(*), intent(inout)	s,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		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 )

SPPSVX: uses the Cholesky factorization A = U**T*U or A = L*L**T to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_sptsv()

pure subroutine, public la_lapack_solve_chol::la_sptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(sp), dimension(*), intent(inout)	d,
		real(sp), dimension(*), intent(inout)	e,
		real(sp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

SPTSV: computes the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**T, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

la_sptsvx()

pure subroutine, public la_lapack_solve_chol::la_sptsvx	(	character, intent(in)	fact,
		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(inout)	df,
		real(sp), dimension(*), intent(inout)	ef,
		real(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(sp), intent(out)	rcond,
		real(sp), dimension(*), intent(out)	ferr,
		real(sp), dimension(*), intent(out)	berr,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

SPTSVX: uses the factorization A = L*D*L**T to compute the solution to a real system of linear equations A*X = B, where A is an N-by-N symmetric positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_wpbsv()

pure subroutine, public la_lapack_solve_chol::la_wpbsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_wpbsvx()

subroutine, public la_lapack_solve_chol::la_wpbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(qp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	s,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

WPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_wposv()

pure subroutine, public la_lapack_solve_chol::la_wposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_wposvx()

subroutine, public la_lapack_solve_chol::la_wposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	s,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

WPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_wppsv()

pure subroutine, public la_lapack_solve_chol::la_wppsv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(*), intent(inout)	ap,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_wppsvx()

subroutine, public la_lapack_solve_chol::la_wppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(*), intent(inout)	ap,
		complex(qp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(qp), dimension(*), intent(inout)	s,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

WPPSVX: uses the Cholesky factorization A = U**H * U or A = L * L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_wptsv()

pure subroutine, public la_lapack_solve_chol::la_wptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(*), intent(inout)	d,
		complex(qp), dimension(*), intent(inout)	e,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

WPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

la_wptsvx()

pure subroutine, public la_lapack_solve_chol::la_wptsvx	(	character, intent(in)	fact,
		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(inout)	df,
		complex(qp), dimension(*), intent(inout)	ef,
		complex(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), intent(out)	rcond,
		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 )

WPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_wzposv()

subroutine, public la_lapack_solve_chol::la_wzposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		complex(qp), dimension(n,*), intent(out)	work,
		complex(dp), dimension(*), intent(out)	swork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

WZPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. WZPOSV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by QLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

la_zcposv()

subroutine, public la_lapack_solve_chol::la_zcposv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		complex(dp), dimension(n,*), intent(out)	work,
		complex(sp), dimension(*), intent(out)	swork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	iter,
		integer(ilp), intent(out)	info )

ZCPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. ZCPOSV first attempts to factorize the matrix in COMPLEX and use this factorization within an iterative refinement procedure to produce a solution with COMPLEX*16 normwise backward error quality (see below). If the approach fails the method switches to a COMPLEX*16 factorization and solve. The iterative refinement is not going to be a winning strategy if the ratio COMPLEX performance over COMPLEX*16 performance is too small. A reasonable strategy should take the number of right-hand sides and the size of the matrix into account. This might be done with a call to ILAENV in the future. Up to now, we always try iterative refinement. The iterative refinement process is stopped if ITER > ITERMAX or for all the RHS we have: RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX where o ITER is the number of the current iteration in the iterative refinement process o RNRM is the infinity-norm of the residual o XNRM is the infinity-norm of the solution o ANRM is the infinity-operator-norm of the matrix A o EPS is the machine epsilon returned by DLAMCH('Epsilon') The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00 respectively.

Here is the call graph for this function:

la_zpbsv()

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

ZPBSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = U**H * U, if UPLO = 'U', or A = L * L**H, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_zpbsvx()

subroutine, public la_lapack_solve_chol::la_zpbsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		complex(dp), dimension(ldafb,*), intent(inout)	afb,
		integer(ilp), intent(in)	ldafb,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	s,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

ZPBSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_zposv()

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

ZPOSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_zposvx()

subroutine, public la_lapack_solve_chol::la_zposvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldaf,*), intent(inout)	af,
		integer(ilp), intent(in)	ldaf,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	s,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

ZPOSVX: uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_zppsv()

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

ZPPSV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as 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 a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Here is the call graph for this function:

la_zppsvx()

subroutine, public la_lapack_solve_chol::la_zppsvx	(	character, intent(in)	fact,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(dp), dimension(*), intent(inout)	ap,
		complex(dp), dimension(*), intent(inout)	afp,
		character, intent(inout)	equed,
		real(dp), dimension(*), intent(inout)	s,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

ZPPSVX: uses the Cholesky factorization A = U**H * U or A = L * L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function:

la_zptsv()

pure subroutine, public la_lapack_solve_chol::la_zptsv	(	integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(dp), dimension(*), intent(inout)	d,
		complex(dp), dimension(*), intent(inout)	e,
		complex(dp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

ZPTSV: computes the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = L*D*L**H, and the factored form of A is then used to solve the system of equations.

Here is the call graph for this function:

la_zptsvx()

pure subroutine, public la_lapack_solve_chol::la_zptsvx	(	character, intent(in)	fact,
		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(inout)	df,
		complex(dp), dimension(*), intent(inout)	ef,
		complex(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldx,*), intent(out)	x,
		integer(ilp), intent(in)	ldx,
		real(dp), intent(out)	rcond,
		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 )

ZPTSVX: uses the factorization A = L*D*L**H to compute the solution to a complex system of linear equations A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.

Here is the call graph for this function: