|
| pure subroutine, public | la_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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_lapack_solve_lu_comp::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.
|
| |
1.13.2