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_qgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info) |
| QGBTF2: 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_qgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| QGBTRS: 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 QGBTRF. | |
| 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_qgttrf (n, dl, d, du, du2, ipiv, info) |
| QGTTRF: 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 subroutine, public | la_qgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) |
| QGTTS2: 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 QGTTRF. | |
| 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 real(qp) function, public | la_qla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb) |
| QLA_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_qlaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) |
| QLAQGB: 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_qlaqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) |
| QLAQGE: 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_qlaswp (n, a, lda, k1, k2, ipiv, incx) |
| QLASWP: 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_qgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) |
| QGBCON: 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 QGBTRF. 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_qgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| QGBEQU: 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_qgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| QGBEQUB: 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 QGEEQU 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_qgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| QGBRFS: 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_qgbtrf (m, n, kl, ku, ab, ldab, ipiv, info) |
| QGBTRF: 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_qgecon (norm, n, a, lda, anorm, rcond, work, iwork, info) |
| QGECON: 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 QGETRF. 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_qgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| QGEEQU: 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_qgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| QGEEQUB: 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 QGEEQU 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_qgesc2 (n, a, lda, rhs, ipiv, jpiv, scale) |
| QGESC2: 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 QGETC2. | |
| 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_qgetc2 (n, a, lda, ipiv, jpiv, info) |
| QGETC2: 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 subroutine, public | la_qgetf2 (m, n, a, lda, ipiv, info) |
| QGETF2: 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 recursive subroutine, public | la_qgetrf2 (m, n, a, lda, ipiv, info) |
| QGETRF2: 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_qgetri (n, a, lda, ipiv, work, lwork, info) |
| QGETRI: computes the inverse of a matrix using the LU factorization computed by QGETRF. 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_qgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info) |
| QGETRS: 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 QGETRF. | |
| 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. | |
| pure subroutine, public | la_qgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) |
| QGTTRS: 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 QGTTRF. | |
| 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. | |
| 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. | |
| real(qp) function, public | la_qla_gbrcond (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, iwork) |
| QLA_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. | |
| 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. | |
| 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. | |
| real(qp) function, public | la_qla_gercond (trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) |
| QLA_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_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_qlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) |
| QLATDF: uses the LU factorization of the n-by-n matrix Z computed by QGETC2 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 QGETC2 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_qgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| QGERFS: 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_qgetrf (m, n, a, lda, ipiv, info) |
| QGETRF: 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_qgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) |
| QGTCON: estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by QGTTRF. 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_qgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| QGTRFS: 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_wgbequ (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| WGBEQU: 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_wgbequb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) |
| WGBEQUB: 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 WGEEQU 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_wgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info) |
| WGBTF2: 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_wgeequ (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| WGEEQU: 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_wgeequb (m, n, a, lda, r, c, rowcnd, colcnd, amax, info) |
| WGEEQUB: 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 WGEEQU 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_wgetc2 (n, a, lda, ipiv, jpiv, info) |
| WGETC2: 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_wgetf2 (m, n, a, lda, ipiv, info) |
| WGETF2: 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_wgttrf (n, dl, d, du, du2, ipiv, info) |
| WGTTRF: 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 subroutine, public | la_wgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) |
| WGTTS2: 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 WGTTRF. | |
| 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 real(qp) function, public | la_wla_gbrpvgrw (n, kl, ku, ncols, ab, ldab, afb, ldafb) |
| WLA_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_wlaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) |
| WLAQGB: 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_wlaqge (m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) |
| WLAQGE: 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_wlaswp (n, a, lda, k1, k2, ipiv, incx) |
| WLASWP: 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_wgbcon (norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) |
| WGBCON: 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 WGBTRF. 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_wgbtrf (m, n, kl, ku, ab, ldab, ipiv, info) |
| WGBTRF: 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_wgbtrs (trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) |
| WGBTRS: 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 WGBTRF. | |
| 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_wgecon (norm, n, a, lda, anorm, rcond, work, rwork, info) |
| WGECON: 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 WGETRF. 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 subroutine, public | la_wgesc2 (n, a, lda, rhs, ipiv, jpiv, scale) |
| WGESC2: 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 WGETC2. | |
| 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 recursive subroutine, public | la_wgetrf2 (m, n, a, lda, ipiv, info) |
| WGETRF2: 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_wgetri (n, a, lda, ipiv, work, lwork, info) |
| WGETRI: computes the inverse of a matrix using the LU factorization computed by WGETRF. 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_wgetrs (trans, n, nrhs, a, lda, ipiv, b, ldb, info) |
| WGETRS: 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 WGETRF. | |
| 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_wgttrs (trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) |
| WGTTRS: 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 WGTTRF. | |
| 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_wlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) |
| WLATDF: 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 WGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by WGETC2 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_wgbrfs (trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WGBRFS: 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_wgerfs (trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WGERFS: 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_wgetrf (m, n, a, lda, ipiv, info) |
| WGETRF: 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_wgtcon (norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) |
| WGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by WGTTRF. 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. | |
| pure subroutine, public | la_wgtrfs (trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| WGTRFS: 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. | |
Detailed Description
LU components: factorization, solve, inverse, condition, equilibration.
Function/Subroutine Documentation
◆ la_cgbcon()
| 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)) ).
◆ la_cgbequ()
| 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.
◆ la_cgbequb()
| 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).
◆ la_cgbrfs()
| 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.
◆ la_cgbtf2()
| 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.
◆ la_cgbtrf()
| 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.
◆ la_cgbtrs()
| 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.
◆ la_cgecon()
| 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)) ).
◆ la_cgeequ()
| 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.
◆ la_cgeequb()
| 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).
◆ la_cgerfs()
| 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.
◆ la_cgesc2()
| 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.
◆ la_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.
◆ la_cgetf2()
| 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.
◆ la_cgetrf()
| 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.
◆ la_cgetrf2()
| 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.
◆ la_cgetri()
| 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).
◆ la_cgetrs()
| 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.
◆ la_cgtcon()
| 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))).
◆ la_cgtrfs()
| 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.
◆ la_cgttrf()
| 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.
◆ la_cgttrs()
| 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.
◆ la_cgtts2()
| 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.
◆ la_cla_gbrpvgrw()
| 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.
◆ la_claqgb()
| 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.
◆ la_claqge()
| 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.
◆ la_claswp()
| 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.
◆ la_clatdf()
| 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.
◆ la_dgbcon()
| 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)) ).
◆ la_dgbequ()
| 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.
◆ la_dgbequb()
| 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).
◆ la_dgbrfs()
| 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.
◆ la_dgbtf2()
| 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.
◆ la_dgbtrf()
| 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.
◆ la_dgbtrs()
| 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.
◆ la_dgecon()
| 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)) ).
◆ la_dgeequ()
| 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.
◆ la_dgeequb()
| 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).
◆ la_dgerfs()
| 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.
◆ la_dgesc2()
| 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.
◆ la_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.
◆ la_dgetf2()
| 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.
◆ la_dgetrf()
| 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.
◆ la_dgetrf2()
| 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.
◆ la_dgetri()
| 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).
◆ la_dgetrs()
| 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.
◆ la_dgtcon()
| 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))).
◆ la_dgtrfs()
| 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.
◆ la_dgttrf()
| 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.
◆ la_dgttrs()
| 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.
◆ la_dgtts2()
| 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.
◆ la_dla_gbrcond()
| 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.
◆ la_dla_gbrpvgrw()
| 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.
◆ la_dla_gercond()
| 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.
◆ la_dlaqgb()
| 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.
◆ la_dlaqge()
| 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.
◆ la_dlaswp()
| 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.
◆ la_dlatdf()
| 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.
◆ la_qgbcon()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGBCON: 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 QGBTRF. 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)) ).
◆ la_qgbequ()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QGBEQU: 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.
◆ la_qgbequb()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QGBEQUB: 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 QGEEQU 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).
◆ la_qgbrfs()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbrfs | ( | 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(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGBRFS: 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.
◆ la_qgbtf2()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbtf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
QGBTF2: 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.
◆ la_qgbtrf()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbtrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
QGBTRF: 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.
◆ la_qgbtrs()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgbtrs | ( | 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(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QGBTRS: 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 QGBTRF.
◆ la_qgecon()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgecon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGECON: 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 QGETRF. 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)) ).
◆ la_qgeequ()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgeequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QGEEQU: 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.
◆ la_qgeequb()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgeequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
QGEEQUB: 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 QGEEQU 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).
◆ la_qgerfs()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgerfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
◆ la_qgesc2()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgesc2 | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | rhs, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv, | ||
| real(qp), intent(out) | scale ) |
QGESC2: 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 QGETC2.
◆ la_qgetc2()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgetc2 | ( | integer(ilp), intent(in) | n, |
| real(qp), 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 ) |
QGETC2: 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.
◆ la_qgetf2()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgetf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
QGETF2: 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.
◆ la_qgetrf()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgetrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
QGETRF: 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.
◆ la_qgetrf2()
| pure recursive subroutine, public la_lapack_solve_lu_comp::la_qgetrf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
QGETRF2: 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.
◆ la_qgetri()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgetri | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QGETRI: computes the inverse of a matrix using the LU factorization computed by QGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
◆ la_qgetrs()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgetrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QGETRS: 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 QGETRF.
◆ la_qgtcon()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgtcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | dl, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | du, | ||
| real(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGTCON: estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by QGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_qgtrfs()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgtrfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | dl, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | du, | ||
| real(qp), dimension(*), intent(in) | dlf, | ||
| real(qp), dimension(*), intent(in) | df, | ||
| real(qp), dimension(*), intent(in) | duf, | ||
| real(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QGTRFS: 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.
◆ la_qgttrf()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgttrf | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | dl, | ||
| real(qp), dimension(*), intent(inout) | d, | ||
| real(qp), dimension(*), intent(inout) | du, | ||
| real(qp), dimension(*), intent(out) | du2, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
QGTTRF: 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.
◆ la_qgttrs()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgttrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | dl, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | du, | ||
| real(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
QGTTRS: 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 QGTTRF.
◆ la_qgtts2()
| pure subroutine, public la_lapack_solve_lu_comp::la_qgtts2 | ( | integer(ilp), intent(in) | itrans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(qp), dimension(*), intent(in) | dl, | ||
| real(qp), dimension(*), intent(in) | d, | ||
| real(qp), dimension(*), intent(in) | du, | ||
| real(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
QGTTS2: 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 QGTTRF.
◆ la_qla_gbrcond()
| real(qp) function, public la_lapack_solve_lu_comp::la_qla_gbrcond | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
QLA_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.
◆ la_qla_gbrpvgrw()
| pure real(qp) function, public la_lapack_solve_lu_comp::la_qla_gbrpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | ncols, | ||
| real(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb ) |
QLA_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.
◆ la_qla_gercond()
| real(qp) function, public la_lapack_solve_lu_comp::la_qla_gercond | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
QLA_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.
◆ la_qlaqgb()
| pure subroutine, public la_lapack_solve_lu_comp::la_qlaqgb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(in) | r, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| real(qp), intent(in) | rowcnd, | ||
| real(qp), intent(in) | colcnd, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
QLAQGB: 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.
◆ la_qlaqge()
| pure subroutine, public la_lapack_solve_lu_comp::la_qlaqge | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | r, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| real(qp), intent(in) | rowcnd, | ||
| real(qp), intent(in) | colcnd, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
QLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
◆ la_qlaswp()
| pure subroutine, public la_lapack_solve_lu_comp::la_qlaswp | ( | integer(ilp), intent(in) | n, |
| real(qp), 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 ) |
QLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
◆ la_qlatdf()
| pure subroutine, public la_lapack_solve_lu_comp::la_qlatdf | ( | integer(ilp), intent(in) | ijob, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(inout) | rhs, | ||
| real(qp), intent(inout) | rdsum, | ||
| real(qp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv ) |
QLATDF: uses the LU factorization of the n-by-n matrix Z computed by QGETC2 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 QGETC2 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.
◆ la_sgbcon()
| 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)) ).
◆ la_sgbequ()
| 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.
◆ la_sgbequb()
| 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).
◆ la_sgbrfs()
| 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.
◆ la_sgbtf2()
| 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.
◆ la_sgbtrf()
| 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.
◆ la_sgbtrs()
| 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.
◆ la_sgecon()
| 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)) ).
◆ la_sgeequ()
| 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.
◆ la_sgeequb()
| 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).
◆ la_sgerfs()
| 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.
◆ la_sgesc2()
| 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.
◆ la_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.
◆ la_sgetf2()
| 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.
◆ la_sgetrf()
| 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.
◆ la_sgetrf2()
| 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.
◆ la_sgetri()
| 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).
◆ la_sgetrs()
| 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.
◆ la_sgtcon()
| 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))).
◆ la_sgtrfs()
| 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.
◆ la_sgttrf()
| 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.
◆ la_sgttrs()
| 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.
◆ la_sgtts2()
| 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.
◆ la_sla_gbrcond()
| 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.
◆ la_sla_gbrpvgrw()
| 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.
◆ la_sla_gercond()
| 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.
◆ la_slaqgb()
| 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.
◆ la_slaqge()
| 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.
◆ la_slaswp()
| 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.
◆ la_slatdf()
| 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.
◆ la_wgbcon()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WGBCON: 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 WGBTRF. 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)) ).
◆ la_wgbequ()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WGBEQU: 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.
◆ la_wgbequb()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WGBEQUB: 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 WGEEQU 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).
◆ la_wgbrfs()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbrfs | ( | 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(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WGBRFS: 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.
◆ la_wgbtf2()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbtf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
WGBTF2: 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.
◆ la_wgbtrf()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbtrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
WGBTRF: 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.
◆ la_wgbtrs()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgbtrs | ( | 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(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WGBTRS: 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 WGBTRF.
◆ la_wgecon()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgecon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WGECON: 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 WGETRF. 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)) ).
◆ la_wgeequ()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgeequ | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WGEEQU: 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.
◆ la_wgeequb()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgeequb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | r, | ||
| real(qp), dimension(*), intent(out) | c, | ||
| real(qp), intent(out) | rowcnd, | ||
| real(qp), intent(out) | colcnd, | ||
| real(qp), intent(out) | amax, | ||
| integer(ilp), intent(out) | info ) |
WGEEQUB: 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 WGEEQU 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).
◆ la_wgerfs()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgerfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WGERFS: improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
◆ la_wgesc2()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgesc2 | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(inout) | rhs, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv, | ||
| real(qp), intent(out) | scale ) |
WGESC2: 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 WGETC2.
◆ la_wgetc2()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgetc2 | ( | integer(ilp), intent(in) | n, |
| complex(qp), 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 ) |
WGETC2: 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.
◆ la_wgetf2()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgetf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
WGETF2: 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.
◆ la_wgetrf()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgetrf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
WGETRF: 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.
◆ la_wgetrf2()
| pure recursive subroutine, public la_lapack_solve_lu_comp::la_wgetrf2 | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
WGETRF2: 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.
◆ la_wgetri()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgetri | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WGETRI: computes the inverse of a matrix using the LU factorization computed by WGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
◆ la_wgetrs()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgetrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WGETRS: 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 WGETRF.
◆ la_wgtcon()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgtcon | ( | character, intent(in) | norm, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(*), intent(in) | dl, | ||
| complex(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | du, | ||
| complex(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(qp), intent(in) | anorm, | ||
| real(qp), intent(out) | rcond, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
WGTCON: estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by WGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
◆ la_wgtrfs()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgtrfs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(*), intent(in) | dl, | ||
| complex(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | du, | ||
| complex(qp), dimension(*), intent(in) | dlf, | ||
| complex(qp), dimension(*), intent(in) | df, | ||
| complex(qp), dimension(*), intent(in) | duf, | ||
| complex(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), dimension(*), intent(out) | ferr, | ||
| real(qp), dimension(*), intent(out) | berr, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
WGTRFS: 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.
◆ la_wgttrf()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgttrf | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(*), intent(inout) | dl, | ||
| complex(qp), dimension(*), intent(inout) | d, | ||
| complex(qp), dimension(*), intent(inout) | du, | ||
| complex(qp), dimension(*), intent(out) | du2, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
WGTTRF: 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.
◆ la_wgttrs()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgttrs | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(*), intent(in) | dl, | ||
| complex(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | du, | ||
| complex(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
WGTTRS: 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 WGTTRF.
◆ la_wgtts2()
| pure subroutine, public la_lapack_solve_lu_comp::la_wgtts2 | ( | integer(ilp), intent(in) | itrans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(qp), dimension(*), intent(in) | dl, | ||
| complex(qp), dimension(*), intent(in) | d, | ||
| complex(qp), dimension(*), intent(in) | du, | ||
| complex(qp), dimension(*), intent(in) | du2, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
WGTTS2: 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 WGTTRF.
◆ la_wla_gbrpvgrw()
| pure real(qp) function, public la_lapack_solve_lu_comp::la_wla_gbrpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| integer(ilp), intent(in) | ncols, | ||
| complex(qp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(qp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb ) |
WLA_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.
◆ la_wlaqgb()
| pure subroutine, public la_lapack_solve_lu_comp::la_wlaqgb | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(qp), dimension(ldab,*), intent(inout) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| real(qp), dimension(*), intent(in) | r, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| real(qp), intent(in) | rowcnd, | ||
| real(qp), intent(in) | colcnd, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
WLAQGB: 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.
◆ la_wlaqge()
| pure subroutine, public la_lapack_solve_lu_comp::la_wlaqge | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | r, | ||
| real(qp), dimension(*), intent(in) | c, | ||
| real(qp), intent(in) | rowcnd, | ||
| real(qp), intent(in) | colcnd, | ||
| real(qp), intent(in) | amax, | ||
| character, intent(out) | equed ) |
WLAQGE: equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
◆ la_wlaswp()
| pure subroutine, public la_lapack_solve_lu_comp::la_wlaswp | ( | integer(ilp), intent(in) | n, |
| complex(qp), 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 ) |
WLASWP: performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
◆ la_wlatdf()
| pure subroutine, public la_lapack_solve_lu_comp::la_wlatdf | ( | integer(ilp), intent(in) | ijob, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(inout) | rhs, | ||
| real(qp), intent(inout) | rdsum, | ||
| real(qp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), dimension(*), intent(in) | jpiv ) |
WLATDF: 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 WGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by WGETC2 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.
◆ la_zgbcon()
| 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)) ).
◆ la_zgbequ()
| 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.
◆ la_zgbequb()
| 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).
◆ la_zgbrfs()
| 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.
◆ la_zgbtf2()
| 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.
◆ la_zgbtrf()
| 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.
◆ la_zgbtrs()
| 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.
◆ la_zgecon()
| 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)) ).
◆ la_zgeequ()
| 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.
◆ la_zgeequb()
| 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).
◆ la_zgerfs()
| 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.
◆ la_zgesc2()
| 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.
◆ la_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.
◆ la_zgetf2()
| 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.
◆ la_zgetrf()
| 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.
◆ la_zgetrf2()
| 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.
◆ la_zgetri()
| 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).
◆ la_zgetrs()
| 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.
◆ la_zgtcon()
| 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))).
◆ la_zgtrfs()
| 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.
◆ la_zgttrf()
| 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.
◆ la_zgttrs()
| 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.
◆ la_zgtts2()
| 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.
◆ la_zla_gbrpvgrw()
| 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.
◆ la_zlaqgb()
| 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.
◆ la_zlaqge()
| 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.
◆ la_zlaswp()
| 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.
◆ la_zlatdf()
| 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.
