Symmetric indefinite components: rook, Aasen and rank-k variants. More...

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

Detailed Description

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

Function/Subroutine Documentation

◆ la_clasyf_aa()

pure subroutine, public la_lapack_solve_ldl_comp2::la_clasyf_aa	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	j1,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	nb,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		integer(ilp), dimension(*), intent(out)	ipiv,
		complex(sp), dimension(ldh,*), intent(inout)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(out)	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.