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

Functions/Subroutines
pure subroutine, public	la_slaqsy (uplo, n, a, lda, s, scond, amax, equed)
	SLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_dlaqsy (uplo, n, a, lda, s, scond, amax, equed)
	DLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_qlaqsy (uplo, n, a, lda, s, scond, amax, equed)
	QLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_chetf2_rk (uplo, n, a, lda, e, ipiv, info)
	CHETF2_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian 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_zhetf2_rk (uplo, n, a, lda, e, ipiv, info)
	ZHETF2_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian 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_whetf2_rk (uplo, n, a, lda, e, ipiv, info)
	WHETF2_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian 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_chetf2_rook (uplo, n, a, lda, ipiv, info)
	CHETF2_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*H or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*H is the conjugate transpose of U, and D is Hermitian 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_zhetf2_rook (uplo, n, a, lda, ipiv, info)
	ZHETF2_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*H or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*H is the conjugate transpose of U, and D is Hermitian 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_whetf2_rook (uplo, n, a, lda, ipiv, info)
	WHETF2_ROOK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDU*H or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U*H is the conjugate transpose of U, and D is Hermitian 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_chetri_rook (uplo, n, a, lda, ipiv, work, info)
	CHETRI_ROOK: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU*H or A = LDL*H computed by CHETRF_ROOK.

pure subroutine, public	la_zhetri_rook (uplo, n, a, lda, ipiv, work, info)
	ZHETRI_ROOK: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU*H or A = LDL*H computed by ZHETRF_ROOK.

pure subroutine, public	la_whetri_rook (uplo, n, a, lda, ipiv, work, info)
	WHETRI_ROOK: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU*H or A = LDL*H computed by WHETRF_ROOK.

pure subroutine, public	la_clahef_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	CLAHEF_RK: computes a partial factorization of a complex Hermitian 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 ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) 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. CLAHEF_RK is an auxiliary routine called by CHETRF_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_zlahef_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	ZLAHEF_RK: computes a partial factorization of a complex Hermitian 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 ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) 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. ZLAHEF_RK is an auxiliary routine called by ZHETRF_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_wlahef_rk (uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info)
	WLAHEF_RK: computes a partial factorization of a complex Hermitian 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 ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) 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. WLAHEF_RK is an auxiliary routine called by WHETRF_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_clahef_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	CLAHEF_ROOK: computes a partial factorization of a complex Hermitian 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 ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF_ROOK is an auxiliary routine called by CHETRF_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_zlahef_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	ZLAHEF_ROOK: computes a partial factorization of a complex Hermitian 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 ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. ZLAHEF_ROOK is an auxiliary routine called by ZHETRF_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_wlahef_rook (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
	WLAHEF_ROOK: computes a partial factorization of a complex Hermitian 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 ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. WLAHEF_ROOK is an auxiliary routine called by WHETRF_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_claqsy (uplo, n, a, lda, s, scond, amax, equed)
	CLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_zlaqsy (uplo, n, a, lda, s, scond, amax, equed)
	ZLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_wlaqsy (uplo, n, a, lda, s, scond, amax, equed)
	WLAQSY: equilibrates a symmetric matrix A using the scaling factors in the vector S.

pure subroutine, public	la_chetrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	CHETRF_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian 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_zhetrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	ZHETRF_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian 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_whetrf_rk (uplo, n, a, lda, e, ipiv, work, lwork, info)
	WHETRF_RK: computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(P*T) or A = PLD(L*H)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, PT is the transpose of P, and D is Hermitian 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_chetrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	CHETRF_ROOK: computes the factorization of a complex Hermitian 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 Hermitian 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_zhetrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	ZHETRF_ROOK: computes the factorization of a complex Hermitian 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 Hermitian 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_whetrf_rook (uplo, n, a, lda, ipiv, work, lwork, info)
	WHETRF_ROOK: computes the factorization of a complex Hermitian 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 Hermitian 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_chetrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	CHETRS_AA: solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by CHETRF_AA.

pure subroutine, public	la_zhetrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	ZHETRS_AA: solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by ZHETRF_AA.

pure subroutine, public	la_whetrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
	WHETRS_AA: solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by WHETRF_AA.

pure subroutine, public	la_chetrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	CHETRS_ROOK: solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF_ROOK.

pure subroutine, public	la_zhetrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	ZHETRS_ROOK: solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF_ROOK.

pure subroutine, public	la_whetrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
	WHETRS_ROOK: solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by WHETRF_ROOK.

pure subroutine, public	la_checon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	CHECON_ROOK: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU*H or A = LDLH computed by CHETRF_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_zhecon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	ZHECON_ROOK: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU*H or A = LDLH computed by CHETRF_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_whecon_rook (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
	WHECON_ROOK: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU*H or A = LDLH computed by ZHETRF_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_chprfs (uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
	CHPRFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.

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

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

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

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

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

pure subroutine, public	la_clahef_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	CLAHEF_AA: factorizes a panel of a complex hermitian 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_zlahef_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLAHEF_AA factorizes a panel of a complex hermitian 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_wlahef_aa (uplo, j1, m, nb, a, lda, ipiv, h, ldh, work)
	DLAHEF_AA factorizes a panel of a complex hermitian 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.

Detailed Description

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

Function/Subroutine Documentation

◆ la_checon_rook()

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

CHECON_ROOK: estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF_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))).