Modules
module	la_lapack_solve_ldl_comp2
	Symmetric indefinite components: rook, Aasen and rank-k variants.

Functions/Subroutines
pure subroutine, public	la_lapack_solve_ldl_comp2::la_slasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	SLASYF_RK: computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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_RK is an auxiliary routine called by SSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dlasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	DLASYF_RK: computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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_RK is an auxiliary routine called by DSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qlasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	QLASYF_RK: computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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_RK is an auxiliary routine called by QSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_slasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	SLASYF_ROOK: computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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_ROOK is an auxiliary routine called by SSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dlasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	DLASYF_ROOK: computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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_ROOK is an auxiliary routine called by DSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qlasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	QLASYF_ROOK: computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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_ROOK is an auxiliary routine called by QSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssptri (uplo, n, ap, ipiv, work, info)
	SSPTRI: computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by SSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsptri (uplo, n, ap, ipiv, work, info)
	DSPTRI: computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by DSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsptri (uplo, n, ap, ipiv, work, info)
	QSPTRI: computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by QSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	SSPTRS: solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by SSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	DSPTRS: solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by DSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	QSPTRS: solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by QSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': SSYCONVF: converts the factorization output format used in SSYTRF provided on entry in parameter A into the factorization output format used in SSYTRF_RK (or SSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in SSYTRF into the format used in SSYTRF_RK (or SSYTRF_BK). If parameter WAY = 'R': SSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in SSYTRF_RK (or SSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in SSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in SSYTRF_RK (or SSYTRF_BK) into the format used in SSYTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': DSYCONVF: converts the factorization output format used in DSYTRF provided on entry in parameter A into the factorization output format used in DSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in DSYTRF into the format used in DSYTRF_RK (or DSYTRF_BK). If parameter WAY = 'R': DSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in DSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in DSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in DSYTRF_RK (or DSYTRF_BK) into the format used in DSYTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': QSYCONVF: converts the factorization output format used in QSYTRF provided on entry in parameter A into the factorization output format used in QSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in QSYTRF into the format used in QSYTRF_RK (or DSYTRF_BK). If parameter WAY = 'R': QSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in QSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in QSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in QSYTRF_RK (or DSYTRF_BK) into the format used in QSYTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': SSYCONVF_ROOK: converts the factorization output format used in SSYTRF_ROOK provided on entry in parameter A into the factorization output format used in SSYTRF_RK (or SSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for SSYTRF_ROOK and SSYTRF_RK (or SSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': SSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in SSYTRF_RK (or SSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in SSYTRF_ROOK that is stored on exit in parameter A. IPIV format for SSYTRF_ROOK and SSYTRF_RK (or SSYTRF_BK) is the same and is not converted.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': DSYCONVF_ROOK: converts the factorization output format used in DSYTRF_ROOK provided on entry in parameter A into the factorization output format used in DSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for DSYTRF_ROOK and DSYTRF_RK (or DSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': DSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in DSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in DSYTRF_ROOK that is stored on exit in parameter A. IPIV format for DSYTRF_ROOK and DSYTRF_RK (or DSYTRF_BK) is the same and is not converted.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': QSYCONVF_ROOK: converts the factorization output format used in QSYTRF_ROOK provided on entry in parameter A into the factorization output format used in QSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for QSYTRF_ROOK and QSYTRF_RK (or DSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': QSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in QSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in QSYTRF_ROOK that is stored on exit in parameter A. IPIV format for QSYTRF_ROOK and QSYTRF_RK (or DSYTRF_BK) is the same and is not converted.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytf2_rk (uplo, n, a, lda, e, ipiv, info)
	SSYTF2_RK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytf2_rk (uplo, n, a, lda, e, ipiv, info)
	DSYTF2_RK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytf2_rk (uplo, n, a, lda, e, ipiv, info)
	QSYTF2_RK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytf2_rook (uplo, n, a, lda, ipiv, info)
	SSYTF2_ROOK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytf2_rook (uplo, n, a, lda, ipiv, info)
	DSYTF2_ROOK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytf2_rook (uplo, n, a, lda, ipiv, info)
	QSYTF2_ROOK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	SSYTRF_RK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	DSYTRF_RK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	QSYTRF_RK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	SSYTRF_ROOK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	DSYTRF_ROOK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	QSYTRF_ROOK: computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytri_rook (uplo, n, a, lda, ipiv, work, info)
	SSYTRI_ROOK: computes the inverse of a real symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by SSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytri_rook (uplo, n, a, lda, ipiv, work, info)
	DSYTRI_ROOK: computes the inverse of a real symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by DSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytri_rook (uplo, n, a, lda, ipiv, work, info)
	QSYTRI_ROOK: computes the inverse of a real symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by QSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	SSYTRS_AA: solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by SSYTRF_AA.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	DSYTRS_AA: solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by DSYTRF_AA.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	QSYTRS_AA: solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by QSYTRF_AA.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	SSYTRS_ROOK: solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	DSYTRS_ROOK: solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	QSYTRS_ROOK: solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by QSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)
	SSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)
	DSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info)
	QSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)
	SSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by SSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)
	DSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by DSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info)
	QSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by QSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_slasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dlasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qlasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_ssytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	SSYTRF_AA: computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_dsytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	DSYTRF_AA: computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_qsytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	QSYTRF_AA: computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_clasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	CLASYF_RK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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. CLASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zlasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	ZLASYF_RK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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. ZLASYF_RK is an auxiliary routine called by ZSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wlasyf_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	WLASYF_RK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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. WLASYF_RK is an auxiliary routine called by WSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_clasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	CLASYF_ROOK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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. CLASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zlasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	ZLASYF_ROOK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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. ZLASYF_ROOK is an auxiliary routine called by ZSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wlasyf_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	WLASYF_ROOK: computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) 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. WLASYF_ROOK is an auxiliary routine called by WSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csptri (uplo, n, ap, ipiv, work, info)
	CSPTRI: computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by CSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsptri (uplo, n, ap, ipiv, work, info)
	ZSPTRI: computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by ZSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsptri (uplo, n, ap, ipiv, work, info)
	WSPTRI: computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDU*T or A = LDL*T computed by WSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	CSPTRS: solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by CSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	ZSPTRS: solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by ZSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
	WSPTRS: solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by WSPTRF.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': CSYCONVF: converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': CSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. CSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': ZSYCONVF: converts the factorization output format used in ZSYTRF provided on entry in parameter A into the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in ZSYTRF into the format used in ZSYTRF_RK (or ZSYTRF_BK). If parameter WAY = 'R': ZSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in ZSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in ZSYTRF_RK (or ZSYTRF_BK) into the format used in ZSYTRF. ZSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in ZHETRF and ZHETRF_RK (or ZHETRF_BK).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsyconvf (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': WSYCONVF: converts the factorization output format used in WSYTRF provided on entry in parameter A into the factorization output format used in WSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in WSYTRF into the format used in WSYTRF_RK (or ZSYTRF_BK). If parameter WAY = 'R': WSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in WSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in WSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in WSYTRF_RK (or ZSYTRF_BK) into the format used in WSYTRF. WSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in WHETRF and WHETRF_RK (or ZHETRF_BK).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': CSYCONVF_ROOK: converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': CSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. CSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': ZSYCONVF_ROOK: converts the factorization output format used in ZSYTRF_ROOK provided on entry in parameter A into the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for ZSYTRF_ROOK and ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': ZSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in ZSYTRF_ROOK that is stored on exit in parameter A. IPIV format for ZSYTRF_ROOK and ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. ZSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in ZHETRF_ROOK and ZHETRF_RK (or ZHETRF_BK).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsyconvf_rook (uplo, way, n, a, lda, e, ipiv, info)
	If parameter WAY = 'C': WSYCONVF_ROOK: converts the factorization output format used in WSYTRF_ROOK provided on entry in parameter A into the factorization output format used in WSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for WSYTRF_ROOK and WSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': WSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in WSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in WSYTRF_ROOK that is stored on exit in parameter A. IPIV format for WSYTRF_ROOK and WSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. WSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in WHETRF_ROOK and WHETRF_RK (or ZHETRF_BK).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytf2_rk (uplo, n, a, lda, e, ipiv, info)
	CSYTF2_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytf2_rk (uplo, n, a, lda, e, ipiv, info)
	ZSYTF2_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytf2_rk (uplo, n, a, lda, e, ipiv, info)
	WSYTF2_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytf2_rook (uplo, n, a, lda, ipiv, info)
	CSYTF2_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytf2_rook (uplo, n, a, lda, ipiv, info)
	ZSYTF2_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytf2_rook (uplo, n, a, lda, ipiv, info)
	WSYTF2_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*T or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	CSYTRF_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	ZSYTRF_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	WSYTRF_RK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(P*T) or A = PLD(L*T)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, PT is the transpose of P, 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. For more information see Further Details section.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	CSYTRF_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	ZSYTRF_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	WSYTRF_ROOK: computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDU*T or A = LDL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytri_rook (uplo, n, a, lda, ipiv, work, info)
	CSYTRI_ROOK: computes the inverse of a complex symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by CSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytri_rook (uplo, n, a, lda, ipiv, work, info)
	ZSYTRI_ROOK: computes the inverse of a complex symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by ZSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytri_rook (uplo, n, a, lda, ipiv, work, info)
	WSYTRI_ROOK: computes the inverse of a complex symmetric matrix A using the factorization A = UDU*T or A = LDL*T computed by WSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CSYTRS_AA: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by CSYTRF_AA.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	ZSYTRS_AA: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by ZSYTRF_AA.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	WSYTRS_AA: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by WSYTRF_AA.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	CSYTRS_ROOK: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	ZSYTRS_ROOK: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	WSYTRS_ROOK: solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by WSYTRF_ROOK.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	ZSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	WSPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	CSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	ZSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by ZSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsycon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	WSYCON_ROOK: estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDU*T or A = LDLT computed by WSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM norm(inv(A))).

pure subroutine, public	la_lapack_solve_ldl_comp2::la_clasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zlasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wlasyf_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_csytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	CSYTRF_AA: computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_zsytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	ZSYTRF_AA: computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

pure subroutine, public	la_lapack_solve_ldl_comp2::la_wsytrf_aa (uplo, n, a, lda, ipiv, work, lwork, info)
	WSYTRF_AA: computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = U*TTU or A = LTL*T where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.

Modules

Functions/Subroutines