fortran-lapack
Loading...
Searching...
No Matches
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_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.
 
pure 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.
 
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_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_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.
 
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_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.
 
pure 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.
 
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_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.
 
pure 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.
 
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_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.
 
pure 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.
 
pure 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.
 
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_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.
 
pure 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.
 
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_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.
 
pure 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.
 
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_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.
 

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()

pure 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()

pure 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()

pure 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()

pure 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()

pure 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()

pure 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()

pure 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_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()

pure 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()

pure 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()

pure 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_zcposv()

pure 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()

pure 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()

pure 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()

pure 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: