|
| pure subroutine, public | la_lapack_solve_ldl_comp::la_slasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) |
| | SLASYF: computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF is an auxiliary routine called by SSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dlasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) |
| | DLASYF: computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF is an auxiliary routine called by DSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qlasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) |
| | QLASYF: computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. QLASYF is an auxiliary routine called by QSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssptrf (uplo, n, ap, ipiv, info) |
| | SSPTRF: computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsptrf (uplo, n, ap, ipiv, info) |
| | DSPTRF: computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsptrf (uplo, n, ap, ipiv, info) |
| | QSPTRF: computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssyconv (uplo, way, n, a, lda, ipiv, e, info) |
| | SSYCONV: convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsyconv (uplo, way, n, a, lda, ipiv, e, info) |
| | DSYCONV: convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsyconv (uplo, way, n, a, lda, ipiv, e, info) |
| | QSYCONV: convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssyequb (uplo, n, a, lda, s, scond, amax, work, info) |
| | SSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsyequb (uplo, n, a, lda, s, scond, amax, work, info) |
| | DSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsyequb (uplo, n, a, lda, s, scond, amax, work, info) |
| | QSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssyswapr (uplo, n, a, lda, i1, i2) |
| | SSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsyswapr (uplo, n, a, lda, i1, i2) |
| | DSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsyswapr (uplo, n, a, lda, i1, i2) |
| | QSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssytri (uplo, n, a, lda, ipiv, work, info) |
| | SSYTRI: computes the inverse of a real symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by SSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsytri (uplo, n, a, lda, ipiv, work, info) |
| | DSYTRI: computes the inverse of a real symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by DSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsytri (uplo, n, a, lda, ipiv, work, info) |
| | QSYTRI: computes the inverse of a real symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by QSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info) |
| | SSYTRS: solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by SSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info) |
| | DSYTRS: solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by DSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info) |
| | QSYTRS: solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by QSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) |
| | SSYTRS2: solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by SSYTRF and converted by SSYCONV.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) |
| | DSYTRS2: solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by DSYTRF and converted by DSYCONV.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) |
| | QSYTRS2: solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by QSYTRF and converted by QSYCONV.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) |
| | SSYTRS_3: solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by SSYTRF_RK or SSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) |
| | DSYTRS_3: solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by DSYTRF_RK or DSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) |
| | QSYTRS_3: solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by QSYTRF_RK or DSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_sspcon (uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) |
| | SSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by SSPTRF. 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_ldl_comp::la_dspcon (uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) |
| | DSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by DSPTRF. 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_ldl_comp::la_qspcon (uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) |
| | QSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by QSPTRF. 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_ldl_comp::la_ssycon (uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) |
| | SSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by SSYTRF. 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_ldl_comp::la_dsycon (uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) |
| | DSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by DSYTRF. 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_ldl_comp::la_qsycon (uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) |
| | QSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by QSYTRF. 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_ldl_comp::la_ssyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| | SSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| | DSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) |
| | QSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssytf2 (uplo, n, a, lda, ipiv, info) |
| | SSYTF2: computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsytf2 (uplo, n, a, lda, ipiv, info) |
| | DSYTF2: computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsytf2 (uplo, n, a, lda, ipiv, info) |
| | QSYTF2: computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_ssytrf (uplo, n, a, lda, ipiv, work, lwork, info) |
| | SSYTRF: computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U**T*D*U or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_dsytrf (uplo, n, a, lda, ipiv, work, lwork, info) |
| | DSYTRF: computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U**T*D*U or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_qsytrf (uplo, n, a, lda, ipiv, work, lwork, info) |
| | QSYTRF: computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U**T*D*U or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_clasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) |
| | CLASYF: computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zlasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) |
| | ZLASYF: computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. ZLASYF is an auxiliary routine called by ZSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wlasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) |
| | WLASYF: computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**T U22**T ) A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. WLASYF is an auxiliary routine called by WSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csptrf (uplo, n, ap, ipiv, info) |
| | CSPTRF: computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsptrf (uplo, n, ap, ipiv, info) |
| | ZSPTRF: computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsptrf (uplo, n, ap, ipiv, info) |
| | WSPTRF: computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csyconv (uplo, way, n, a, lda, ipiv, e, info) |
| | CSYCONV: convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsyconv (uplo, way, n, a, lda, ipiv, e, info) |
| | ZSYCONV: converts A given by ZHETRF into L and D or vice-versa. Get nondiagonal elements of D (returned in workspace) and apply or reverse permutation done in TRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsyconv (uplo, way, n, a, lda, ipiv, e, info) |
| | WSYCONV: converts A given by WHETRF into L and D or vice-versa. Get nondiagonal elements of D (returned in workspace) and apply or reverse permutation done in TRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csyequb (uplo, n, a, lda, s, scond, amax, work, info) |
| | CSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsyequb (uplo, n, a, lda, s, scond, amax, work, info) |
| | ZSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsyequb (uplo, n, a, lda, s, scond, amax, work, info) |
| | WSYEQUB: computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csyswapr (uplo, n, a, lda, i1, i2) |
| | CSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsyswapr (uplo, n, a, lda, i1, i2) |
| | ZSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsyswapr (uplo, n, a, lda, i1, i2) |
| | WSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csytf2 (uplo, n, a, lda, ipiv, info) |
| | CSYTF2: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsytf2 (uplo, n, a, lda, ipiv, info) |
| | ZSYTF2: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsytf2 (uplo, n, a, lda, ipiv, info) |
| | WSYTF2: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csytrf (uplo, n, a, lda, ipiv, work, lwork, info) |
| | CSYTRF: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsytrf (uplo, n, a, lda, ipiv, work, lwork, info) |
| | ZSYTRF: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsytrf (uplo, n, a, lda, ipiv, work, lwork, info) |
| | WSYTRF: computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**T or A = L*D*L**T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csytri (uplo, n, a, lda, ipiv, work, info) |
| | CSYTRI: computes the inverse of a complex symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsytri (uplo, n, a, lda, ipiv, work, info) |
| | ZSYTRI: computes the inverse of a complex symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by ZSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsytri (uplo, n, a, lda, ipiv, work, info) |
| | WSYTRI: computes the inverse of a complex symmetric indefinite matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by WSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info) |
| | CSYTRS: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info) |
| | ZSYTRS: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by ZSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsytrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info) |
| | WSYTRS: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by WSYTRF.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) |
| | CSYTRS2: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF and converted by CSYCONV.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) |
| | ZSYTRS2: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by ZSYTRF and converted by ZSYCONV.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsytrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) |
| | WSYTRS2: solves a system of linear equations A*X = B with a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by WSYTRF and converted by WSYCONV.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_csytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) |
| | CSYTRS_3: solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) |
| | ZSYTRS_3: solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by ZSYTRF_RK or ZSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsytrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) |
| | WSYTRS_3: solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by WSYTRF_RK or ZSYTRF_BK: A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**T (or L**T) is the transpose of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
|
| |
| real(sp) function, public | la_lapack_solve_ldl_comp::la_cla_herpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| | CLA_HERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
|
| |
| real(dp) function, public | la_lapack_solve_ldl_comp::la_zla_herpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| | ZLA_HERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
|
| |
| real(qp) function, public | la_lapack_solve_ldl_comp::la_wla_herpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| | WLA_HERPVGRW: 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_ldl_comp::la_cspcon (uplo, n, ap, ipiv, anorm, rcond, work, info) |
| | CSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSPTRF. 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_ldl_comp::la_zspcon (uplo, n, ap, ipiv, anorm, rcond, work, info) |
| | ZSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by ZSPTRF. 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_ldl_comp::la_wspcon (uplo, n, ap, ipiv, anorm, rcond, work, info) |
| | WSPCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by WSPTRF. 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_ldl_comp::la_csycon (uplo, n, a, lda, ipiv, anorm, rcond, work, info) |
| | CSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by CSYTRF. 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_ldl_comp::la_zsycon (uplo, n, a, lda, ipiv, anorm, rcond, work, info) |
| | ZSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by ZSYTRF. 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_ldl_comp::la_wsycon (uplo, n, a, lda, ipiv, anorm, rcond, work, info) |
| | WSYCON: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = U*D*U**T or A = L*D*L**T computed by WSYTRF. 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_ldl_comp::la_csyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| | CSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_zsyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| | ZSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
|
| |
| pure subroutine, public | la_lapack_solve_ldl_comp::la_wsyrfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) |
| | WSYRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
|
| |
1.13.2