fortran-lapack
Loading...
Searching...
No Matches
la_lapack_solve_ldl_comp3 Module Reference

Hermitian indefinite components: Bunch-Kaufman factorization, solve, inverse. More...

Functions/Subroutines

pure subroutine, public la_cheswapr (uplo, n, a, lda, i1, i2)
 CHESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix.
 
pure subroutine, public la_zheswapr (uplo, n, a, lda, i1, i2)
 ZHESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix.
 
pure subroutine, public la_chetf2 (uplo, n, a, lda, ipiv, info)
 CHETF2: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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 (uplo, n, a, lda, ipiv, info)
 ZHETF2: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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 (uplo, n, a, lda, ipiv, work, info)
 CHETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF.
 
pure subroutine, public la_zhetri (uplo, n, a, lda, ipiv, work, info)
 ZHETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHETRF.
 
pure subroutine, public la_chetrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)
 CHETRS_3: solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
 
pure subroutine, public la_zhetrs_3 (uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info)
 ZHETRS_3: solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by ZHETRF_RK or ZHETRF_BK: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
 
pure subroutine, public la_chptrf (uplo, n, ap, ipiv, info)
 CHPTRF: computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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.
 
pure subroutine, public la_zhptrf (uplo, n, ap, ipiv, info)
 ZHPTRF: computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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.
 
pure subroutine, public la_chptri (uplo, n, ap, ipiv, work, info)
 CHPTRI: computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF.
 
pure subroutine, public la_zhptri (uplo, n, ap, ipiv, work, info)
 ZHPTRI: computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHPTRF.
 
pure subroutine, public la_clahef (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
 CLAHEF: computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) 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 is an auxiliary routine called by CHETRF. 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 (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
 ZLAHEF: computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) 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 is an auxiliary routine called by ZHETRF. 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_cheequb (uplo, n, a, lda, s, scond, amax, work, info)
 CHEEQUB: computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
 
pure subroutine, public la_zheequb (uplo, n, a, lda, s, scond, amax, work, info)
 ZHEEQUB: computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
 
pure subroutine, public la_chetrf (uplo, n, a, lda, ipiv, work, lwork, info)
 CHETRF: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**H or A = L*D*L**H 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 (uplo, n, a, lda, ipiv, work, lwork, info)
 ZHETRF: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**H or A = L*D*L**H 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 (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
 CHETRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF.
 
pure subroutine, public la_zhetrs (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
 ZHETRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHETRF.
 
pure subroutine, public la_chetrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)
 CHETRS2: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF and converted by CSYCONV.
 
pure subroutine, public la_zhetrs2 (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)
 ZHETRS2: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHETRF and converted by ZSYCONV.
 
pure subroutine, public la_chptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
 CHPTRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A stored in packed format using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF.
 
pure subroutine, public la_zhptrs (uplo, n, nrhs, ap, ipiv, b, ldb, info)
 ZHPTRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A stored in packed format using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHPTRF.
 
pure subroutine, public la_checon (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
 CHECON: 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. 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 (uplo, n, a, lda, ipiv, anorm, rcond, work, info)
 ZHECON: 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 ZHETRF. 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_cherfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 CHERFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.
 
pure subroutine, public la_zherfs (uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info)
 ZHERFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.
 
pure subroutine, public la_chpcon (uplo, n, ap, ipiv, anorm, rcond, work, info)
 CHPCON: estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF. 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_zhpcon (uplo, n, ap, ipiv, anorm, rcond, work, info)
 ZHPCON: estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
 

Detailed Description

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

Function/Subroutine Documentation

◆ la_checon()

pure subroutine, public la_lapack_solve_ldl_comp3::la_checon ( 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: 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. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_cheequb()

pure subroutine, public la_lapack_solve_ldl_comp3::la_cheequb ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(sp), dimension(*), intent(out) s,
real(sp), intent(out) scond,
real(sp), intent(out) amax,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

CHEEQUB: computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

Here is the call graph for this function:

◆ la_cherfs()

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

CHERFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_cheswapr()

pure subroutine, public la_lapack_solve_ldl_comp3::la_cheswapr ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,n), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(in) i1,
integer(ilp), intent(in) i2 )

CHESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix.

Here is the call graph for this function:

◆ la_chetf2()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chetf2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(out) ipiv,
integer(ilp), intent(out) info )

CHETF2: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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.

Here is the call graph for this function:

◆ la_chetrf()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chetrf ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(out) ipiv,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

CHETRF: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**H or A = L*D*L**H 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.

Here is the call graph for this function:

◆ la_chetri()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chetri ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(in) ipiv,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

CHETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF.

Here is the call graph for this function:

◆ la_chetrs()

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

CHETRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF.

Here is the call graph for this function:

◆ la_chetrs2()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chetrs2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(in) ipiv,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

CHETRS2: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHETRF and converted by CSYCONV.

Here is the call graph for this function:

◆ la_chetrs_3()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chetrs_3 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(sp), dimension(*), intent(in) e,
integer(ilp), dimension(*), intent(in) ipiv,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

CHETRS_3: solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

Here is the call graph for this function:

◆ la_chpcon()

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

CHPCON: estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_chptrf()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chptrf ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
integer(ilp), dimension(*), intent(out) ipiv,
integer(ilp), intent(out) info )

CHPTRF: computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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.

Here is the call graph for this function:

◆ la_chptri()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chptri ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(sp), dimension(*), intent(inout) ap,
integer(ilp), dimension(*), intent(in) ipiv,
complex(sp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

CHPTRI: computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF.

Here is the call graph for this function:

◆ la_chptrs()

pure subroutine, public la_lapack_solve_ldl_comp3::la_chptrs ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(sp), dimension(*), intent(in) ap,
integer(ilp), dimension(*), intent(in) ipiv,
complex(sp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

CHPTRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A stored in packed format using the factorization A = U*D*U**H or A = L*D*L**H computed by CHPTRF.

Here is the call graph for this function:

◆ la_clahef()

pure subroutine, public la_lapack_solve_ldl_comp3::la_clahef ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nb,
integer(ilp), intent(out) kb,
complex(sp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(out) ipiv,
complex(sp), dimension(ldw,*), intent(out) w,
integer(ilp), intent(in) ldw,
integer(ilp), intent(out) info )

CLAHEF: computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) 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 is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

Here is the call graph for this function:

◆ la_zhecon()

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

ZHECON: 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 ZHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_zheequb()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zheequb ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
real(dp), dimension(*), intent(out) s,
real(dp), intent(out) scond,
real(dp), intent(out) amax,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

ZHEEQUB: computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.

Here is the call graph for this function:

◆ la_zherfs()

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

ZHERFS: improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.

Here is the call graph for this function:

◆ la_zheswapr()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zheswapr ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,n), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), intent(in) i1,
integer(ilp), intent(in) i2 )

ZHESWAPR: applies an elementary permutation on the rows and the columns of a hermitian matrix.

Here is the call graph for this function:

◆ la_zhetf2()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhetf2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(out) ipiv,
integer(ilp), intent(out) info )

ZHETF2: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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.

Here is the call graph for this function:

◆ la_zhetrf()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhetrf ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(out) ipiv,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(in) lwork,
integer(ilp), intent(out) info )

ZHETRF: computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = U*D*U**H or A = L*D*L**H 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.

Here is the call graph for this function:

◆ la_zhetri()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhetri ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(in) ipiv,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

ZHETRI: computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHETRF.

Here is the call graph for this function:

◆ la_zhetrs()

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

ZHETRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHETRF.

Here is the call graph for this function:

◆ la_zhetrs2()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhetrs2 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(in) ipiv,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

ZHETRS2: solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHETRF and converted by ZSYCONV.

Here is the call graph for this function:

◆ la_zhetrs_3()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhetrs_3 ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(lda,*), intent(in) a,
integer(ilp), intent(in) lda,
complex(dp), dimension(*), intent(in) e,
integer(ilp), dimension(*), intent(in) ipiv,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

ZHETRS_3: solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by ZHETRF_RK or ZHETRF_BK: A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T), where U (or L) is unit upper (or lower) triangular matrix, U**H (or L**H) is the conjugate of U (or L), P is a permutation matrix, P**T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.

Here is the call graph for this function:

◆ la_zhpcon()

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

ZHPCON: estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

Here is the call graph for this function:

◆ la_zhptrf()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhptrf ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
integer(ilp), dimension(*), intent(out) ipiv,
integer(ilp), intent(out) info )

ZHPTRF: computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = U*D*U**H or A = L*D*L**H 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.

Here is the call graph for this function:

◆ la_zhptri()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhptri ( character, intent(in) uplo,
integer(ilp), intent(in) n,
complex(dp), dimension(*), intent(inout) ap,
integer(ilp), dimension(*), intent(in) ipiv,
complex(dp), dimension(*), intent(out) work,
integer(ilp), intent(out) info )

ZHPTRI: computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHPTRF.

Here is the call graph for this function:

◆ la_zhptrs()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zhptrs ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nrhs,
complex(dp), dimension(*), intent(in) ap,
integer(ilp), dimension(*), intent(in) ipiv,
complex(dp), dimension(ldb,*), intent(inout) b,
integer(ilp), intent(in) ldb,
integer(ilp), intent(out) info )

ZHPTRS: solves a system of linear equations A*X = B with a complex Hermitian matrix A stored in packed format using the factorization A = U*D*U**H or A = L*D*L**H computed by ZHPTRF.

Here is the call graph for this function:

◆ la_zlahef()

pure subroutine, public la_lapack_solve_ldl_comp3::la_zlahef ( character, intent(in) uplo,
integer(ilp), intent(in) n,
integer(ilp), intent(in) nb,
integer(ilp), intent(out) kb,
complex(dp), dimension(lda,*), intent(inout) a,
integer(ilp), intent(in) lda,
integer(ilp), dimension(*), intent(out) ipiv,
complex(dp), dimension(ldw,*), intent(out) w,
integer(ilp), intent(in) ldw,
integer(ilp), intent(out) info )

ZLAHEF: computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12**H U22**H ) A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) 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 is an auxiliary routine called by ZHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').

Here is the call graph for this function: