la_lapack_solve_ldl_comp Module Reference

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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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.
pure subroutine, public	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_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_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_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_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_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_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_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_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.
pure subroutine, public	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.

Detailed Description

Symmetric indefinite components: Bunch-Kaufman factorization, solve, inverse.

Function/Subroutine Documentation

la_cla_herpvgrw()

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.

Here is the call graph for this function:

la_clasyf()

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').

Here is the call graph for this function:

la_cspcon()

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))).

la_csptrf()

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.

Here is the call graph for this function:

la_csycon()

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))).

Here is the call graph for this function:

la_csyconv()

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.

Here is the call graph for this function:

la_csyequb()

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.

Here is the call graph for this function:

la_csyrfs()

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.

Here is the call graph for this function:

la_csyswapr()

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.

Here is the call graph for this function:

la_csytf2()

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.

Here is the call graph for this function:

la_csytrf()

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.

Here is the call graph for this function:

la_csytri()

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.

Here is the call graph for this function:

la_csytrs()

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.

Here is the call graph for this function:

la_csytrs2()

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.

Here is the call graph for this function:

la_csytrs_3()

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.

Here is the call graph for this function:

la_dlasyf()

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').

Here is the call graph for this function:

la_dspcon()

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))).

Here is the call graph for this function:

la_dsptrf()

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.

Here is the call graph for this function:

la_dsycon()

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))).

Here is the call graph for this function:

la_dsyconv()

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.

Here is the call graph for this function:

la_dsyequb()

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.

Here is the call graph for this function:

la_dsyrfs()

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.

Here is the call graph for this function:

la_dsyswapr()

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.

Here is the call graph for this function:

la_dsytf2()

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.

Here is the call graph for this function:

la_dsytrf()

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.

Here is the call graph for this function:

la_dsytri()

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.

Here is the call graph for this function:

la_dsytrs()

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.

Here is the call graph for this function:

la_dsytrs2()

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.

Here is the call graph for this function:

la_dsytrs_3()

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.

Here is the call graph for this function:

la_qlasyf()

pure subroutine, public la_lapack_solve_ldl_comp::la_qlasyf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(qp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	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').

Here is the call graph for this function:

la_qspcon()

pure subroutine, public la_lapack_solve_ldl_comp::la_qspcon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(in)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), intent(in)	anorm,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

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))).

Here is the call graph for this function:

la_qsptrf()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsptrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_qsycon()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsycon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), intent(in)	anorm,
		real(qp), intent(out)	rcond,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

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))).

Here is the call graph for this function:

la_qsyconv()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsyconv	(	character, intent(in)	uplo,
		character, intent(in)	way,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), dimension(*), intent(out)	e,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_qsyequb()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsyequb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	s,
		real(qp), intent(out)	scond,
		real(qp), intent(out)	amax,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_qsyrfs()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsyrfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_qsyswapr()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsyswapr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,n), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(in)	i1,
		integer(ilp), intent(in)	i2 )

QSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.

Here is the call graph for this function:

la_qsytf2()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsytf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_qsytrf()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsytrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_qsytri()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsytri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_qsytrs()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsytrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_qsytrs2()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsytrs2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_qsytrs_3()

pure subroutine, public la_lapack_solve_ldl_comp::la_qsytrs_3	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		real(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(in)	e,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_slasyf()

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').

Here is the call graph for this function:

la_sspcon()

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))).

Here is the call graph for this function:

la_ssptrf()

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.

Here is the call graph for this function:

la_ssycon()

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))).

Here is the call graph for this function:

la_ssyconv()

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.

Here is the call graph for this function:

la_ssyequb()

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.

Here is the call graph for this function:

la_ssyrfs()

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.

Here is the call graph for this function:

la_ssyswapr()

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.

Here is the call graph for this function:

la_ssytf2()

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.

Here is the call graph for this function:

la_ssytrf()

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.

Here is the call graph for this function:

la_ssytri()

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.

Here is the call graph for this function:

la_ssytrs()

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.

Here is the call graph for this function:

la_ssytrs2()

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.

Here is the call graph for this function:

la_ssytrs_3()

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.

Here is the call graph for this function:

la_wla_herpvgrw()

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

Here is the call graph for this function:

la_wlasyf()

pure subroutine, public la_lapack_solve_ldl_comp::la_wlasyf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nb,
		integer(ilp), intent(out)	kb,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(qp), dimension(ldw,*), intent(out)	w,
		integer(ilp), intent(in)	ldw,
		integer(ilp), intent(out)	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').

Here is the call graph for this function:

la_wspcon()

pure subroutine, public la_lapack_solve_ldl_comp::la_wspcon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	ap,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), intent(in)	anorm,
		real(qp), intent(out)	rcond,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

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))).

la_wsptrf()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsptrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(inout)	ap,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_wsycon()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsycon	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		real(qp), intent(in)	anorm,
		real(qp), intent(out)	rcond,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

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))).

Here is the call graph for this function:

la_wsyconv()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsyconv	(	character, intent(in)	uplo,
		character, intent(in)	way,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(qp), dimension(*), intent(out)	e,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_wsyequb()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsyequb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	s,
		real(qp), intent(out)	scond,
		real(qp), intent(out)	amax,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_wsyrfs()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsyrfs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldaf,*), intent(in)	af,
		integer(ilp), intent(in)	ldaf,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldx,*), intent(inout)	x,
		integer(ilp), intent(in)	ldx,
		real(qp), dimension(*), intent(out)	ferr,
		real(qp), dimension(*), intent(out)	berr,
		complex(qp), dimension(*), intent(out)	work,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_wsyswapr()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsyswapr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,n), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), intent(in)	i1,
		integer(ilp), intent(in)	i2 )

WSYSWAPR: applies an elementary permutation on the rows and the columns of a symmetric matrix.

Here is the call graph for this function:

la_wsytf2()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsytf2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_wsytrf()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsytrf	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_wsytri()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsytri	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_wsytrs()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsytrs	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	info )

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.

Here is the call graph for this function:

la_wsytrs2()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsytrs2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_wsytrs_3()

pure subroutine, public la_lapack_solve_ldl_comp::la_wsytrs_3	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	nrhs,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(*), intent(in)	e,
		integer(ilp), dimension(*), intent(in)	ipiv,
		complex(qp), dimension(ldb,*), intent(inout)	b,
		integer(ilp), intent(in)	ldb,
		integer(ilp), intent(out)	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.

Here is the call graph for this function:

la_zla_herpvgrw()

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.

Here is the call graph for this function:

la_zlasyf()

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').

Here is the call graph for this function:

la_zspcon()

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))).

la_zsptrf()

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.

Here is the call graph for this function:

la_zsycon()

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))).

Here is the call graph for this function:

la_zsyconv()

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.

Here is the call graph for this function:

la_zsyequb()

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.

Here is the call graph for this function:

la_zsyrfs()

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.

Here is the call graph for this function:

la_zsyswapr()

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.

Here is the call graph for this function:

la_zsytf2()

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.

Here is the call graph for this function:

la_zsytrf()

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.

Here is the call graph for this function:

la_zsytri()

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.

Here is the call graph for this function:

la_zsytrs()

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.

Here is the call graph for this function:

la_zsytrs2()

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.

Here is the call graph for this function:

la_zsytrs_3()

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.

Here is the call graph for this function: