|
fortran-lapack
|
Symmetric indefinite components: Bunch-Kaufman factorization, solve, inverse. More...
Functions/Subroutines | |
| pure subroutine, public | 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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. | |
| real(sp) function, public | 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. | |
| pure subroutine, public | la_cla_herpvgrw_sub (uplo, n, info, a, lda, af, ldaf, ipiv, work, res) |
| Pure subroutine form of CLA_HERPVGRW: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | 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. | |
| pure subroutine, public | la_zla_herpvgrw_sub (uplo, n, info, a, lda, af, ldaf, ipiv, work, res) |
| Pure subroutine form of ZLA_HERPVGRW: the same arguments, followed by RES, which returns the value of the function. | |
| pure subroutine, public | 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_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_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_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_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_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. | |
Symmetric indefinite components: Bunch-Kaufman factorization, solve, inverse.
| real(sp) function, public la_lapack_solve_ldl_comp::la_cla_herpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | 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.

| pure subroutine, public la_lapack_solve_ldl_comp::la_cla_herpvgrw_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_HERPVGRW: the same arguments, followed by RES, which returns the value of the function.
| pure subroutine, public la_lapack_solve_ldl_comp::la_clasyf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| integer(ilp), intent(out) | kb, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(sp), dimension(ldw,*), intent(out) | w, | ||
| integer(ilp), intent(in) | ldw, | ||
| integer(ilp), intent(out) | 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_cspcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(in) | ap, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
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_csptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | 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_csycon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
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_csyconv | ( | character, intent(in) | uplo, |
| character, intent(in) | way, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(*), intent(out) | e, | ||
| integer(ilp), intent(out) | 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_csyequb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_csyrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
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_csyswapr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,n), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | i1, | ||
| integer(ilp), intent(in) | 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_csytf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
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_csytrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | 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_csytri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_csytrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
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_csytrs2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_csytrs_3 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | e, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | 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_dlasyf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| integer(ilp), intent(out) | kb, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(dp), dimension(ldw,*), intent(out) | w, | ||
| integer(ilp), intent(in) | ldw, | ||
| integer(ilp), intent(out) | 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_dspcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(in) | ap, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
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_dsptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | 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_dsycon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
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_dsyconv | ( | character, intent(in) | uplo, |
| character, intent(in) | way, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | e, | ||
| integer(ilp), intent(out) | 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_dsyequb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_dsyrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
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_dsyswapr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,n), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | i1, | ||
| integer(ilp), intent(in) | 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_dsytf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
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_dsytrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | 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_dsytri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_dsytrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
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_dsytrs2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_dsytrs_3 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | e, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | 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_slasyf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| integer(ilp), intent(out) | kb, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(sp), dimension(ldw,*), intent(out) | w, | ||
| integer(ilp), intent(in) | ldw, | ||
| integer(ilp), intent(out) | 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_sspcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
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_ssptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | 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_ssycon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), intent(in) | anorm, | ||
| real(sp), intent(out) | rcond, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
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_ssyconv | ( | character, intent(in) | uplo, |
| character, intent(in) | way, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | e, | ||
| integer(ilp), intent(out) | 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_ssyequb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | s, | ||
| real(sp), intent(out) | scond, | ||
| real(sp), intent(out) | amax, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_ssyrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), dimension(*), intent(out) | ferr, | ||
| real(sp), dimension(*), intent(out) | berr, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
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_ssyswapr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,n), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | i1, | ||
| integer(ilp), intent(in) | 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_ssytf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
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_ssytrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | 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_ssytri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_ssytrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
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_ssytrs2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_ssytrs_3 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | e, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | 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.

| real(dp) function, public la_lapack_solve_ldl_comp::la_zla_herpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | 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.

| pure subroutine, public la_lapack_solve_ldl_comp::la_zla_herpvgrw_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_HERPVGRW: the same arguments, followed by RES, which returns the value of the function.
| pure subroutine, public la_lapack_solve_ldl_comp::la_zlasyf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nb, | ||
| integer(ilp), intent(out) | kb, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(dp), dimension(ldw,*), intent(out) | w, | ||
| integer(ilp), intent(in) | ldw, | ||
| integer(ilp), intent(out) | 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_zspcon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(in) | ap, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
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_zsptrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(*), intent(inout) | ap, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | 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_zsycon | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), intent(in) | anorm, | ||
| real(dp), intent(out) | rcond, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
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_zsyconv | ( | character, intent(in) | uplo, |
| character, intent(in) | way, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(*), intent(out) | e, | ||
| integer(ilp), intent(out) | 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_zsyequb | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | s, | ||
| real(dp), intent(out) | scond, | ||
| real(dp), intent(out) | amax, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_zsyrfs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldx,*), intent(inout) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), dimension(*), intent(out) | ferr, | ||
| real(dp), dimension(*), intent(out) | berr, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(out) | info ) |
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_zsyswapr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,n), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(in) | i1, | ||
| integer(ilp), intent(in) | 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_zsytf2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| integer(ilp), intent(out) | info ) |
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_zsytrf | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(out) | ipiv, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | 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_zsytri | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_zsytrs | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | info ) |
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_zsytrs2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | 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_zsytrs_3 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | nrhs, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | e, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(out) | 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.
