|
fortran-lapack
|
LU drivers: general, banded and tridiagonal systems. More...
Functions/Subroutines | |
| pure subroutine, public | la_sgtsv (n, nrhs, dl, d, du, b, ldb, info) |
| SGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL. | |
| pure subroutine, public | la_dgtsv (n, nrhs, dl, d, du, b, ldb, info) |
| DGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL. | |
| pure subroutine, public | la_sgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| SGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_dgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| DGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_sgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) |
| SGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_dgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) |
| DGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_sgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) |
| SGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N 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_dgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) |
| DGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N 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_dsgesv (n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, iter, info) |
| DSGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. DSGESV 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_sgesv (n, nrhs, a, lda, ipiv, b, ldb, info) |
| SGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_dgesv (n, nrhs, a, lda, ipiv, b, ldb, info) |
| DGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_sgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) |
| SGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N 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_dgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) |
| DGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N 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_cgtsv (n, nrhs, dl, d, du, b, ldb, info) |
| CGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL. | |
| pure subroutine, public | la_zgtsv (n, nrhs, dl, d, du, b, ldb, info) |
| ZGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL. | |
| pure subroutine, public | la_cgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| CGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_zgbsv (n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| ZGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_cgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_zgbsvx (fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| ZGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_cgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N 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_zgtsvx (fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| ZGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N 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_zcgesv (n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, rwork, iter, info) |
| ZCGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. ZCGESV 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_cgesv (n, nrhs, a, lda, ipiv, b, ldb, info) |
| CGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_zgesv (n, nrhs, a, lda, ipiv, b, ldb, info) |
| ZGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B. | |
| pure subroutine, public | la_cgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| CGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N 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_zgesvx (fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) |
| ZGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided. | |
LU drivers: general, banded and tridiagonal systems.
| pure subroutine, public la_lapack_solve_lu::la_cgbsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_cgbsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(sp), dimension(*), intent(inout) | r, | ||
| real(sp), dimension(*), intent(inout) | c, | ||
| 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 ) |
CGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_lapack_solve_lu::la_cgesv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_cgesvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(sp), dimension(*), intent(inout) | r, | ||
| real(sp), dimension(*), intent(inout) | c, | ||
| 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 ) |
CGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N 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_lapack_solve_lu::la_cgtsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(*), intent(inout) | dl, | ||
| complex(sp), dimension(*), intent(inout) | d, | ||
| complex(sp), dimension(*), intent(inout) | du, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL.
| pure subroutine, public la_lapack_solve_lu::la_cgtsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(*), intent(in) | dl, | ||
| complex(sp), dimension(*), intent(in) | d, | ||
| complex(sp), dimension(*), intent(in) | du, | ||
| complex(sp), dimension(*), intent(inout) | dlf, | ||
| complex(sp), dimension(*), intent(inout) | df, | ||
| complex(sp), dimension(*), intent(inout) | duf, | ||
| complex(sp), dimension(*), intent(inout) | du2, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| 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 ) |
CGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N 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_lapack_solve_lu::la_dgbsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_dgbsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(dp), dimension(*), intent(inout) | r, | ||
| real(dp), dimension(*), intent(inout) | c, | ||
| 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 ) |
DGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_lapack_solve_lu::la_dgesv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_dgesvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(dp), dimension(*), intent(inout) | r, | ||
| real(dp), dimension(*), intent(inout) | c, | ||
| 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 ) |
DGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N 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_lapack_solve_lu::la_dgtsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(inout) | dl, | ||
| real(dp), dimension(*), intent(inout) | d, | ||
| real(dp), dimension(*), intent(inout) | du, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL.
| pure subroutine, public la_lapack_solve_lu::la_dgtsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(*), intent(in) | dl, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| real(dp), dimension(*), intent(in) | du, | ||
| real(dp), dimension(*), intent(inout) | dlf, | ||
| real(dp), dimension(*), intent(inout) | df, | ||
| real(dp), dimension(*), intent(inout) | duf, | ||
| real(dp), dimension(*), intent(inout) | du2, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| 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), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N 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_lapack_solve_lu::la_dsgesv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| 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 ) |
DSGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. DSGESV 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_lapack_solve_lu::la_sgbsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SGBSV: computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_sgbsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(sp), dimension(*), intent(inout) | r, | ||
| real(sp), dimension(*), intent(inout) | c, | ||
| 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 ) |
SGBSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_lapack_solve_lu::la_sgesv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SGESV: computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_sgesvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(sp), dimension(*), intent(inout) | r, | ||
| real(sp), dimension(*), intent(inout) | c, | ||
| 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 ) |
SGESVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B, where A is an N-by-N 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_lapack_solve_lu::la_sgtsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(inout) | dl, | ||
| real(sp), dimension(*), intent(inout) | d, | ||
| real(sp), dimension(*), intent(inout) | du, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SGTSV: solves the equation A*X = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL.
| pure subroutine, public la_lapack_solve_lu::la_sgtsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(*), intent(in) | dl, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| real(sp), dimension(*), intent(in) | du, | ||
| real(sp), dimension(*), intent(inout) | dlf, | ||
| real(sp), dimension(*), intent(inout) | df, | ||
| real(sp), dimension(*), intent(inout) | duf, | ||
| real(sp), dimension(*), intent(inout) | du2, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| 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), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGTSVX: uses the LU factorization to compute the solution to a real system of linear equations A * X = B or A**T * X = B, where A is a tridiagonal matrix of order N 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_lapack_solve_lu::la_zcgesv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| 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 ) |
ZCGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. ZCGESV 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_lapack_solve_lu::la_zgbsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZGBSV: computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_zgbsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(dp), dimension(*), intent(inout) | r, | ||
| real(dp), dimension(*), intent(inout) | c, | ||
| 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 ) |
ZGBSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, 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_lapack_solve_lu::la_zgesv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZGESV: computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

| pure subroutine, public la_lapack_solve_lu::la_zgesvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| 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, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| character, intent(inout) | equed, | ||
| real(dp), dimension(*), intent(inout) | r, | ||
| real(dp), dimension(*), intent(inout) | c, | ||
| 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 ) |
ZGESVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N 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_lapack_solve_lu::la_zgtsv | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(*), intent(inout) | dl, | ||
| complex(dp), dimension(*), intent(inout) | d, | ||
| complex(dp), dimension(*), intent(inout) | du, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZGTSV: solves the equation A*X = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A**T *X = B may be solved by interchanging the order of the arguments DU and DL.
| pure subroutine, public la_lapack_solve_lu::la_zgtsvx | ( | character, intent(in) | fact, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(*), intent(in) | dl, | ||
| complex(dp), dimension(*), intent(in) | d, | ||
| complex(dp), dimension(*), intent(in) | du, | ||
| complex(dp), dimension(*), intent(inout) | dlf, | ||
| complex(dp), dimension(*), intent(inout) | df, | ||
| complex(dp), dimension(*), intent(inout) | duf, | ||
| complex(dp), dimension(*), intent(inout) | du2, | ||
| integer(ilp), dimension(*), intent(inout) | ipiv, | ||
| 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 ) |
ZGTSVX: uses the LU factorization to compute the solution to a complex system of linear equations A * X = B, A**T * X = B, or A**H * X = B, where A is a tridiagonal matrix of order N and X and B are N-by-NRHS matrices. Error bounds on the solution and a condition estimate are also provided.
