|
fortran-lapack
|
LU components: factorization, solve, inverse, condition, equilibration. More...
Functions/Subroutines | |
| pure subroutine, public | la_sgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info) |
| SGBTF2: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_dgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info) |
| DGBTF2: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_sgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| SGBTRS: solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by SGBTRF. | |
| pure subroutine, public | la_dgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| DGBTRS: solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by DGBTRF. | |
| pure subroutine, public | la_sgttrf (n, dl, d, du, du2, ipiv, info) |
| SGTTRF: computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals. | |
| pure subroutine, public | la_dgttrf (n, dl, d, du, du2, ipiv, info) |
| DGTTRF: computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals. | |
| pure subroutine, public | la_sgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) |
| SGTTS2: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by SGTTRF. | |
| pure subroutine, public | la_dgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) |
| DGTTS2: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by DGTTRF. | |
| pure real(sp) function, public | la_sla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb) |
| SLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure real(dp) function, public | la_dla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb) |
| DLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_slaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) |
| SLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C. | |
| pure subroutine, public | la_dlaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) |
| DLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C. | |
| pure subroutine, public | la_slaqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) |
| SLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C. | |
| pure subroutine, public | la_dlaqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) |
| DLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C. | |
| pure subroutine, public | la_slaswp (n, a, lda, k1, k2, ipiv, incx) |
| SLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. | |
| pure subroutine, public | la_dlaswp (n, a, lda, k1, k2, ipiv, incx) |
| DLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. | |
| pure subroutine, public | la_sgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) |
| SGBCON: estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_dgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) |
| DGBCON: estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_sgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| SGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_dgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| DGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_sgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| SGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_dgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| DGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_sgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| SGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| DGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_sgbtrf (m, n, kl, ku, ab, ldab, ipiv, info) |
| SGBTRF: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_dgbtrf (m, n, kl, ku, ab, ldab, ipiv, info) |
| DGBTRF: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_sgecon (norm, n, a, lda, anorm, rcond, work, iwork, info) |
| SGECON: estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_dgecon (norm, n, a, lda, anorm, rcond, work, iwork, info) |
| DGECON: estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_sgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| SGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_dgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| DGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_sgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| SGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_dgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| DGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_sgesc2 (n, a, lda, rhs, ipiv, jpiv, scale) |
| SGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by SGETC2. | |
| pure subroutine, public | la_dgesc2 (n, a, lda, rhs, ipiv, jpiv, scale) |
| DGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by DGETC2. | |
| pure subroutine, public | la_sgetc2 (n, a, lda, ipiv, jpiv, info) |
| SGETC2: computes an LU factorization with complete pivoting of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is the Level 2 BLAS algorithm. | |
| pure subroutine, public | la_dgetc2 (n, a, lda, ipiv, jpiv, info) |
| DGETC2: computes an LU factorization with complete pivoting of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is the Level 2 BLAS algorithm. | |
| pure subroutine, public | la_sgetf2 (m, n, a, lda, ipiv, info) |
| SGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm. | |
| pure subroutine, public | la_dgetf2 (m, n, a, lda, ipiv, info) |
| DGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm. | |
| pure recursive subroutine, public | la_sgetrf2 (m, n, a, lda, ipiv, info) |
| SGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21. | |
| pure recursive subroutine, public | la_dgetrf2 (m, n, a, lda, ipiv, info) |
| DGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21. | |
| pure subroutine, public | la_sgetri (n, a, lda, ipiv, work, lwork, info) |
| SGETRI: computes the inverse of a matrix using the LU factorization computed by SGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). | |
| pure subroutine, public | la_dgetri (n, a, lda, ipiv, work, lwork, info) |
| DGETRI: computes the inverse of a matrix using the LU factorization computed by DGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). | |
| pure subroutine, public | la_sgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info) |
| SGETRS: solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF. | |
| pure subroutine, public | la_dgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info) |
| DGETRS: solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by DGETRF. | |
| pure subroutine, public | la_sgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) |
| SGTTRS: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by SGTTRF. | |
| pure subroutine, public | la_dgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) |
| DGTTRS: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by DGTTRF. | |
| real(sp) function, public | la_sla_gbrcond (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork) |
| SLA_GBRCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_sla_gbrcond_sub (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork, res) |
| Pure subroutine form of SLA_GBRCOND: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_dla_gbrcond (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork) |
| DLA_GBRCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_dla_gbrcond_sub (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork, res) |
| Pure subroutine form of DLA_GBRCOND: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_sla_gercond (trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) |
| SLA_GERCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_sla_gercond_sub (trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork, res) |
| Pure subroutine form of SLA_GERCOND: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_dla_gercond (trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) |
| DLA_GERCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_dla_gercond_sub (trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork, res) |
| Pure subroutine form of DLA_GERCOND: the same arguments, followed by RES, which returns the value of the function. | |
| pure subroutine, public | la_slatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) |
| SLATDF: uses the LU factorization of the n-by-n matrix Z computed by SGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by SGETC2 has the form Z = P*L*U*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular. | |
| pure subroutine, public | la_dlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) |
| DLATDF: uses the LU factorization of the n-by-n matrix Z computed by DGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by DGETC2 has the form Z = P*L*U*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular. | |
| pure subroutine, public | la_sgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| SGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| DGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_sgetrf (m, n, a, lda, ipiv, info) |
| SGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm. | |
| pure subroutine, public | la_dgetrf (m, n, a, lda, ipiv, info) |
| DGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm. | |
| pure subroutine, public | la_sgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) |
| SGTCON: estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by SGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_dgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) |
| DGTCON: estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by DGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_sgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| SGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_dgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| DGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_cgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| CGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_zgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| ZGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_cgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| CGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_zgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| ZGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_cgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info) |
| CGBTF2: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_zgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info) |
| ZGBTF2: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS. | |
| pure subroutine, public | la_cgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| CGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_zgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| ZGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. | |
| pure subroutine, public | la_cgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| CGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_zgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| ZGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix). | |
| pure subroutine, public | la_cgetc2 (n, a, lda, ipiv, jpiv, info) |
| CGETC2: computes an LU factorization, using complete pivoting, of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is a level 1 BLAS version of the algorithm. | |
| pure subroutine, public | la_zgetc2 (n, a, lda, ipiv, jpiv, info) |
| ZGETC2: computes an LU factorization, using complete pivoting, of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is a level 1 BLAS version of the algorithm. | |
| pure subroutine, public | la_cgetf2 (m, n, a, lda, ipiv, info) |
| CGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm. | |
| pure subroutine, public | la_zgetf2 (m, n, a, lda, ipiv, info) |
| ZGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm. | |
| pure subroutine, public | la_cgttrf (n, dl, d, du, du2, ipiv, info) |
| CGTTRF: computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals. | |
| pure subroutine, public | la_zgttrf (n, dl, d, du, du2, ipiv, info) |
| ZGTTRF: computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals. | |
| pure subroutine, public | la_cgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) |
| CGTTS2: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF. | |
| pure subroutine, public | la_zgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) |
| ZGTTS2: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by ZGTTRF. | |
| pure real(sp) function, public | la_cla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb) |
| CLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure real(dp) function, public | la_zla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb) |
| ZLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_claqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) |
| CLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C. | |
| pure subroutine, public | la_zlaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) |
| ZLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C. | |
| pure subroutine, public | la_claqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) |
| CLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C. | |
| pure subroutine, public | la_zlaqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) |
| ZLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C. | |
| pure subroutine, public | la_claswp (n, a, lda, k1, k2, ipiv, incx) |
| CLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. | |
| pure subroutine, public | la_zlaswp (n, a, lda, k1, k2, ipiv, incx) |
| ZLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. | |
| pure subroutine, public | la_cgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) |
| CGBCON: estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_zgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) |
| ZGBCON: estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_cgbtrf (m, n, kl, ku, ab, ldab, ipiv, info) |
| CGBTRF: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_zgbtrf (m, n, kl, ku, ab, ldab, ipiv, info) |
| ZGBTRF: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS. | |
| pure subroutine, public | la_cgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| CGBTRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general band matrix A using the LU factorization computed by CGBTRF. | |
| pure subroutine, public | la_zgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| ZGBTRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general band matrix A using the LU factorization computed by ZGBTRF. | |
| pure subroutine, public | la_cgecon (norm, n, a, lda, anorm, rcond, work, rwork, info) |
| CGECON: estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_zgecon (norm, n, a, lda, anorm, rcond, work, rwork, info) |
| ZGECON: estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). | |
| pure subroutine, public | la_cgesc2 (n, a, lda, rhs, ipiv, jpiv, scale) |
| CGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by CGETC2. | |
| pure subroutine, public | la_zgesc2 (n, a, lda, rhs, ipiv, jpiv, scale) |
| ZGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by ZGETC2. | |
| pure recursive subroutine, public | la_cgetrf2 (m, n, a, lda, ipiv, info) |
| CGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21. | |
| pure recursive subroutine, public | la_zgetrf2 (m, n, a, lda, ipiv, info) |
| ZGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21. | |
| pure subroutine, public | la_cgetri (n, a, lda, ipiv, work, lwork, info) |
| CGETRI: computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). | |
| pure subroutine, public | la_zgetri (n, a, lda, ipiv, work, lwork, info) |
| ZGETRI: computes the inverse of a matrix using the LU factorization computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). | |
| pure subroutine, public | la_cgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info) |
| CGETRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF. | |
| pure subroutine, public | la_zgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info) |
| ZGETRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by ZGETRF. | |
| pure subroutine, public | la_cgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) |
| CGTTRS: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF. | |
| pure subroutine, public | la_zgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) |
| ZGTTRS: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by ZGTTRF. | |
| pure subroutine, public | la_clatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) |
| CLATDF: computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular. | |
| pure subroutine, public | la_zlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) |
| ZLATDF: computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by ZGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by ZGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular. | |
| pure subroutine, public | la_cgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_cgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_cgetrf (m, n, a, lda, ipiv, info) |
| CGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm. | |
| pure subroutine, public | la_zgetrf (m, n, a, lda, ipiv, info) |
| ZGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm. | |
| pure subroutine, public | la_cgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) |
| CGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_zgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) |
| ZGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by ZGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))). | |
| pure subroutine, public | la_cgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| CGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution. | |
| pure subroutine, public | la_zgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| ZGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution. | |
LU components: factorization, solve, inverse, condition, equilibration.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgbcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CGBCON: estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| pure subroutine, public la_lapack_solve_lu_comp::la_cgbequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgbequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| pure subroutine, public la_lapack_solve_lu_comp::la_cgbrfs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgbtf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
CGBTF2: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgbtrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
CGBTRF: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgbtrs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CGBTRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general band matrix A using the LU factorization computed by CGBTRF.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgecon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CGECON: estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| pure subroutine, public la_lapack_solve_lu_comp::la_cgeequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgeequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
CGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| pure subroutine, public la_lapack_solve_lu_comp::la_cgerfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgesc2 | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(inout) | rhs, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv, | ||
| real(sp), intent(out) | scale ) |
CGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by CGETC2.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgetc2 | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), dimension(*), intent(out) | jpiv, | ||
| integer(ilp), intent(out) | info ) |
CGETC2: computes an LU factorization, using complete pivoting, of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is a level 1 BLAS version of the algorithm.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgetf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
CGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgetrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
CGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

| pure recursive subroutine, public la_lapack_solve_lu_comp::la_cgetrf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
CGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgetri | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CGETRI: computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| pure subroutine, public la_lapack_solve_lu_comp::la_cgetrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CGETRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgtcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(in) | dl, | ||
| complex(sp), dimension(*), intent(in) | d, | ||
| complex(sp), dimension(*), intent(in) | du, | ||
| complex(sp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
CGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

| pure subroutine, public la_lapack_solve_lu_comp::la_cgtrfs | ( | 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(in) | dlf, | ||
| complex(sp), dimension(*), intent(in) | df, | ||
| complex(sp), dimension(*), intent(in) | duf, | ||
| complex(sp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
CGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgttrf | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(inout) | dl, | ||
| complex(sp), dimension(*), intent(inout) | d, | ||
| complex(sp), dimension(*), intent(inout) | du, | ||
| complex(sp), dimension(*), intent(out) | du2, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
CGTTRF: computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| pure subroutine, public la_lapack_solve_lu_comp::la_cgttrs | ( | 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
CGTTRS: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_cgtts2 | ( | integer(ilp), intent(in) | itrans, |
| 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
CGTTS2: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.
| pure real(sp) function, public la_lapack_solve_lu_comp::la_cla_gbrpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | ncols, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb ) |
CLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_solve_lu_comp::la_claqgb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(in) | r, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| real(sp), intent(in) | rowcnd, | ||
| real(sp), intent(in) | colcnd, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
CLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| pure subroutine, public la_lapack_solve_lu_comp::la_claqge | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | r, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| real(sp), intent(in) | rowcnd, | ||
| real(sp), intent(in) | colcnd, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
CLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| pure subroutine, public la_lapack_solve_lu_comp::la_claswp | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | k1, | ||
| integer(ilp), intent(in) | k2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | incx ) |
CLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| pure subroutine, public la_lapack_solve_lu_comp::la_clatdf | ( | integer(ilp), intent(in) | ijob, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(sp), dimension(*), intent(inout) | rhs, | ||
| real(sp), intent(inout) | rdsum, | ||
| real(sp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv ) |
CLATDF: computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGBCON: estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbrfs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbtf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
DGBTF2: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbtrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
DGBTRF: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgbtrs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DGBTRS: solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by DGBTRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgecon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGECON: estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

| pure subroutine, public la_lapack_solve_lu_comp::la_dgeequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgeequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
DGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

| pure subroutine, public la_lapack_solve_lu_comp::la_dgerfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgesc2 | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(inout) | rhs, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv, | ||
| real(dp), intent(out) | scale ) |
DGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by DGETC2.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgetc2 | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), dimension(*), intent(out) | jpiv, | ||
| integer(ilp), intent(out) | info ) |
DGETC2: computes an LU factorization with complete pivoting of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is the Level 2 BLAS algorithm.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgetf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
DGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgetrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
DGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

| pure recursive subroutine, public la_lapack_solve_lu_comp::la_dgetrf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
DGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgetri | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DGETRI: computes the inverse of a matrix using the LU factorization computed by DGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

| pure subroutine, public la_lapack_solve_lu_comp::la_dgetrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DGETRS: solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by DGETRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgtcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(in) | dl, | ||
| real(dp), dimension(*), intent(in) | d, | ||
| real(dp), dimension(*), intent(in) | du, | ||
| real(dp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGTCON: estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by DGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

| pure subroutine, public la_lapack_solve_lu_comp::la_dgtrfs | ( | 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(in) | dlf, | ||
| real(dp), dimension(*), intent(in) | df, | ||
| real(dp), dimension(*), intent(in) | duf, | ||
| real(dp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgttrf | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(inout) | dl, | ||
| real(dp), dimension(*), intent(inout) | d, | ||
| real(dp), dimension(*), intent(inout) | du, | ||
| real(dp), dimension(*), intent(out) | du2, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
DGTTRF: computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| pure subroutine, public la_lapack_solve_lu_comp::la_dgttrs | ( | 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
DGTTRS: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by DGTTRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_dgtts2 | ( | integer(ilp), intent(in) | itrans, |
| 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
DGTTS2: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by DGTTRF.
| real(dp) function, public la_lapack_solve_lu_comp::la_dla_gbrcond | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
DLA_GBRCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.

| pure subroutine, public la_lapack_solve_lu_comp::la_dla_gbrcond_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of DLA_GBRCOND: the same arguments, followed by RES, which returns the value of the function.

| pure real(dp) function, public la_lapack_solve_lu_comp::la_dla_gbrpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | ncols, | ||
| real(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb ) |
DLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| real(dp) function, public la_lapack_solve_lu_comp::la_dla_gercond | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
DLA_GERCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.

| pure subroutine, public la_lapack_solve_lu_comp::la_dla_gercond_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of DLA_GERCOND: the same arguments, followed by RES, which returns the value of the function.

| pure subroutine, public la_lapack_solve_lu_comp::la_dlaqgb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(in) | r, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| real(dp), intent(in) | rowcnd, | ||
| real(dp), intent(in) | colcnd, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
DLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

| pure subroutine, public la_lapack_solve_lu_comp::la_dlaqge | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | r, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| real(dp), intent(in) | rowcnd, | ||
| real(dp), intent(in) | colcnd, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
DLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

| pure subroutine, public la_lapack_solve_lu_comp::la_dlaswp | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | k1, | ||
| integer(ilp), intent(in) | k2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | incx ) |
DLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| pure subroutine, public la_lapack_solve_lu_comp::la_dlatdf | ( | integer(ilp), intent(in) | ijob, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(dp), dimension(*), intent(inout) | rhs, | ||
| real(dp), intent(inout) | rdsum, | ||
| real(dp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv ) |
DLATDF: uses the LU factorization of the n-by-n matrix Z computed by DGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by DGETC2 has the form Z = P*L*U*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGBCON: estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbrfs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbtf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
SGBTF2: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbtrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
SGBTRF: computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgbtrs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SGBTRS: solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by SGBTRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgecon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGECON: estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).

| pure subroutine, public la_lapack_solve_lu_comp::la_sgeequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgeequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | r, | ||
| real(sp), dimension(*), intent(out) | c, | ||
| real(sp), intent(out) | rowcnd, | ||
| real(sp), intent(out) | colcnd, | ||
| real(sp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
SGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).

| pure subroutine, public la_lapack_solve_lu_comp::la_sgerfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgesc2 | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | rhs, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv, | ||
| real(sp), intent(out) | scale ) |
SGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by SGETC2.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgetc2 | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), dimension(*), intent(out) | jpiv, | ||
| integer(ilp), intent(out) | info ) |
SGETC2: computes an LU factorization with complete pivoting of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is the Level 2 BLAS algorithm.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgetf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
SGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgetrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
SGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

| pure recursive subroutine, public la_lapack_solve_lu_comp::la_sgetrf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
SGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgetri | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SGETRI: computes the inverse of a matrix using the LU factorization computed by SGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

| pure subroutine, public la_lapack_solve_lu_comp::la_sgetrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SGETRS: solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgtcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | dl, | ||
| real(sp), dimension(*), intent(in) | d, | ||
| real(sp), dimension(*), intent(in) | du, | ||
| real(sp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGTCON: estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by SGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

| pure subroutine, public la_lapack_solve_lu_comp::la_sgtrfs | ( | 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(in) | dlf, | ||
| real(sp), dimension(*), intent(in) | df, | ||
| real(sp), dimension(*), intent(in) | duf, | ||
| real(sp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
SGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgttrf | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | dl, | ||
| real(sp), dimension(*), intent(inout) | d, | ||
| real(sp), dimension(*), intent(inout) | du, | ||
| real(sp), dimension(*), intent(out) | du2, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
SGTTRF: computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| pure subroutine, public la_lapack_solve_lu_comp::la_sgttrs | ( | 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
SGTTRS: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by SGTTRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_sgtts2 | ( | integer(ilp), intent(in) | itrans, |
| 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
SGTTS2: solves one of the systems of equations A*X = B or A**T*X = B, with a tridiagonal matrix A using the LU factorization computed by SGTTRF.
| real(sp) function, public la_lapack_solve_lu_comp::la_sla_gbrcond | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
SLA_GBRCOND: Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.

| pure subroutine, public la_lapack_solve_lu_comp::la_sla_gbrcond_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of SLA_GBRCOND: the same arguments, followed by RES, which returns the value of the function.

| pure real(sp) function, public la_lapack_solve_lu_comp::la_sla_gbrpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | ncols, | ||
| real(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb ) |
SLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| real(sp) function, public la_lapack_solve_lu_comp::la_sla_gercond | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
SLA_GERCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.

| pure subroutine, public la_lapack_solve_lu_comp::la_sla_gercond_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of SLA_GERCOND: the same arguments, followed by RES, which returns the value of the function.

| pure subroutine, public la_lapack_solve_lu_comp::la_slaqgb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(sp), dimension(*), intent(in) | r, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| real(sp), intent(in) | rowcnd, | ||
| real(sp), intent(in) | colcnd, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
SLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.

| pure subroutine, public la_lapack_solve_lu_comp::la_slaqge | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | r, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| real(sp), intent(in) | rowcnd, | ||
| real(sp), intent(in) | colcnd, | ||
| real(sp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
SLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.

| pure subroutine, public la_lapack_solve_lu_comp::la_slaswp | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | k1, | ||
| integer(ilp), intent(in) | k2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | incx ) |
SLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| pure subroutine, public la_lapack_solve_lu_comp::la_slatdf | ( | integer(ilp), intent(in) | ijob, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(sp), dimension(*), intent(inout) | rhs, | ||
| real(sp), intent(inout) | rdsum, | ||
| real(sp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv ) |
SLATDF: uses the LU factorization of the n-by-n matrix Z computed by SGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by SGETC2 has the form Z = P*L*U*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgbcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZGBCON: estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| pure subroutine, public la_lapack_solve_lu_comp::la_zgbequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZGBEQU: computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgbequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZGBEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| pure subroutine, public la_lapack_solve_lu_comp::la_zgbrfs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZGBRFS: improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgbtf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
ZGBTF2: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgbtrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
ZGBTRF: computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgbtrs | ( | 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(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZGBTRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgecon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZGECON: estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| pure subroutine, public la_lapack_solve_lu_comp::la_zgeequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZGEEQU: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgeequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | r, | ||
| real(dp), dimension(*), intent(out) | c, | ||
| real(dp), intent(out) | rowcnd, | ||
| real(dp), intent(out) | colcnd, | ||
| real(dp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
ZGEEQUB: computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| pure subroutine, public la_lapack_solve_lu_comp::la_zgerfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgesc2 | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(inout) | rhs, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv, | ||
| real(dp), intent(out) | scale ) |
ZGESC2: solves a system of linear equations A * X = scale* RHS with a general N-by-N matrix A using the LU factorization with complete pivoting computed by ZGETC2.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgetc2 | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), dimension(*), intent(out) | jpiv, | ||
| integer(ilp), intent(out) | info ) |
ZGETC2: computes an LU factorization, using complete pivoting, of the n-by-n matrix A. The factorization has the form A = P * L * U * Q, where P and Q are permutation matrices, L is lower triangular with unit diagonal elements and U is upper triangular. This is a level 1 BLAS version of the algorithm.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgetf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
ZGETF2: computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 2 BLAS version of the algorithm.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgetrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
ZGETRF: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.

| pure recursive subroutine, public la_lapack_solve_lu_comp::la_zgetrf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
ZGETRF2: computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ --—|--— ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ — ], [ A12 ] [ A12 ] do the swaps on [ — ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgetri | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZGETRI: computes the inverse of a matrix using the LU factorization computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| pure subroutine, public la_lapack_solve_lu_comp::la_zgetrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZGETRS: solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by ZGETRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgtcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(in) | dl, | ||
| complex(dp), dimension(*), intent(in) | d, | ||
| complex(dp), dimension(*), intent(in) | du, | ||
| complex(dp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
ZGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by ZGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

| pure subroutine, public la_lapack_solve_lu_comp::la_zgtrfs | ( | 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(in) | dlf, | ||
| complex(dp), dimension(*), intent(in) | df, | ||
| complex(dp), dimension(*), intent(in) | duf, | ||
| complex(dp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
ZGTRFS: improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgttrf | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(*), intent(inout) | dl, | ||
| complex(dp), dimension(*), intent(inout) | d, | ||
| complex(dp), dimension(*), intent(inout) | du, | ||
| complex(dp), dimension(*), intent(out) | du2, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
ZGTTRF: computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| pure subroutine, public la_lapack_solve_lu_comp::la_zgttrs | ( | 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
ZGTTRS: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by ZGTTRF.

| pure subroutine, public la_lapack_solve_lu_comp::la_zgtts2 | ( | integer(ilp), intent(in) | itrans, |
| 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(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
ZGTTS2: solves one of the systems of equations A * X = B, A**T * X = B, or A**H * X = B, with a tridiagonal matrix A using the LU factorization computed by ZGTTRF.
| pure real(dp) function, public la_lapack_solve_lu_comp::la_zla_gbrpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | ncols, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb ) |
ZLA_GBRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_solve_lu_comp::la_zlaqgb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(dp), dimension(*), intent(in) | r, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| real(dp), intent(in) | rowcnd, | ||
| real(dp), intent(in) | colcnd, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
ZLAQGB: equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| pure subroutine, public la_lapack_solve_lu_comp::la_zlaqge | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | r, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| real(dp), intent(in) | rowcnd, | ||
| real(dp), intent(in) | colcnd, | ||
| real(dp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
ZLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| pure subroutine, public la_lapack_solve_lu_comp::la_zlaswp | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | k1, | ||
| integer(ilp), intent(in) | k2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | incx ) |
ZLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| pure subroutine, public la_lapack_solve_lu_comp::la_zlatdf | ( | integer(ilp), intent(in) | ijob, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(dp), dimension(*), intent(inout) | rhs, | ||
| real(dp), intent(inout) | rdsum, | ||
| real(dp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv ) |
ZLATDF: computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by ZGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by ZGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.
