Provided by: liblapack-doc_3.11.0-2_all 
NAME
complex16HEsolve - complex16
SYNOPSIS
Functions
subroutine zhesv (UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, INFO)
ZHESV computes the solution to system of linear equations A * X = B for HE matrices
subroutine zhesv_aa (UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, INFO)
ZHESV_AA computes the solution to system of linear equations A * X = B for HE
matrices
subroutine zhesv_aa_2stage (UPLO, N, NRHS, A, LDA, TB, LTB, IPIV, IPIV2, B, LDB, WORK,
LWORK, INFO)
ZHESV_AA_2STAGE computes the solution to system of linear equations A * X = B for HE
matrices
subroutine zhesv_rk (UPLO, N, NRHS, A, LDA, E, IPIV, B, LDB, WORK, LWORK, INFO)
ZHESV_RK computes the solution to system of linear equations A * X = B for SY
matrices
subroutine zhesv_rook (UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, INFO)
ZHESV_ROOK computes the solution to a system of linear equations A * X = B for HE
matrices using the bounded Bunch-Kaufman ('rook') diagonal pivoting method
subroutine zhesvx (FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, RCOND,
FERR, BERR, WORK, LWORK, RWORK, INFO)
ZHESVX computes the solution to system of linear equations A * X = B for HE matrices
subroutine zhesvxx (FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, EQUED, S, B, LDB, X, LDX,
RCOND, RPVGRW, BERR, N_ERR_BNDS, ERR_BNDS_NORM, ERR_BNDS_COMP, NPARAMS, PARAMS, WORK,
RWORK, INFO)
ZHESVXX computes the solution to system of linear equations A * X = B for HE matrices
Detailed Description
This is the group of complex16 solve driver functions for HE matrices
Function Documentation
subroutine zhesv (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB,
complex*16, dimension( * ) WORK, integer LWORK, integer INFO)
ZHESV computes the solution to system of linear equations A * X = B for HE matrices
Purpose:
ZHESV computes the solution to a complex system of linear equations
A * X = B,
where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS
matrices.
The diagonal pivoting method is used to factor A as
A = U * D * U**H, if UPLO = 'U', or
A = L * D * L**H, if UPLO = 'L',
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. The factored form of A is then
used to solve the system of equations A * X = B.
Parameters
UPLO
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
On entry, the Hermitian matrix A. If UPLO = 'U', the leading
N-by-N upper triangular part of A contains the upper
triangular part of the matrix A, and the strictly lower
triangular part of A is not referenced. If UPLO = 'L', the
leading N-by-N lower triangular part of A contains the lower
triangular part of the matrix A, and the strictly upper
triangular part of A is not referenced.
On exit, if INFO = 0, the block diagonal matrix D and the
multipliers used to obtain the factor U or L from the
factorization A = U*D*U**H or A = L*D*L**H as computed by
ZHETRF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D, as
determined by ZHETRF. If IPIV(k) > 0, then rows and columns
k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1
diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,
then rows and columns k-1 and -IPIV(k) were interchanged and
D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and
IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and
-IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2
diagonal block.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the N-by-NRHS right hand side matrix B.
On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK
LWORK is INTEGER
The length of WORK. LWORK >= 1, and for best performance
LWORK >= max(1,N*NB), where NB is the optimal blocksize for
ZHETRF.
for LWORK < N, TRS will be done with Level BLAS 2
for LWORK >= N, TRS will be done with Level BLAS 3
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, D(i,i) is exactly zero. The factorization
has been completed, but the block diagonal matrix D is
exactly singular, so the solution could not be computed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
subroutine zhesv_aa (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * )
A, integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( * ) WORK, integer LWORK, integer INFO)
ZHESV_AA computes the solution to system of linear equations A * X = B for HE matrices
Purpose:
ZHESV_AA computes the solution to a complex system of linear equations
A * X = B,
where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS
matrices.
Aasen's algorithm is used to factor A as
A = U**H * T * U, if UPLO = 'U', or
A = L * T * L**H, if UPLO = 'L',
where U (or L) is a product of permutation and unit upper (lower)
triangular matrices, and T is Hermitian and tridiagonal. The factored form
of A is then used to solve the system of equations A * X = B.
Parameters
UPLO
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
On entry, the Hermitian matrix A. If UPLO = 'U', the leading
N-by-N upper triangular part of A contains the upper
triangular part of the matrix A, and the strictly lower
triangular part of A is not referenced. If UPLO = 'L', the
leading N-by-N lower triangular part of A contains the lower
triangular part of the matrix A, and the strictly upper
triangular part of A is not referenced.
On exit, if INFO = 0, the tridiagonal matrix T and the
multipliers used to obtain the factor U or L from the
factorization A = U**H*T*U or A = L*T*L**H as computed by
ZHETRF_AA.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
On exit, it contains the details of the interchanges, i.e.,
the row and column k of A were interchanged with the
row and column IPIV(k).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the N-by-NRHS right hand side matrix B.
On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK
LWORK is INTEGER
The length of WORK. LWORK >= MAX(1,2*N,3*N-2), and for best
performance LWORK >= max(1,N*NB), where NB is the optimal
blocksize for ZHETRF.
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, D(i,i) is exactly zero. The factorization
has been completed, but the block diagonal matrix D is
exactly singular, so the solution could not be computed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
subroutine zhesv_aa_2stage (character UPLO, integer N, integer NRHS, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( * ) TB, integer LTB, integer, dimension( *
) IPIV, integer, dimension( * ) IPIV2, complex*16, dimension( ldb, * ) B, integer LDB,
complex*16, dimension( * ) WORK, integer LWORK, integer INFO)
ZHESV_AA_2STAGE computes the solution to system of linear equations A * X = B for HE
matrices
Purpose:
ZHESV_AA_2STAGE computes the solution to a complex system of
linear equations
A * X = B,
where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS
matrices.
Aasen's 2-stage algorithm is used to factor A as
A = U**H * T * U, if UPLO = 'U', or
A = L * T * L**H, if UPLO = 'L',
where U (or L) is a product of permutation and unit upper (lower)
triangular matrices, and T is Hermitian and band. The matrix T is
then LU-factored with partial pivoting. The factored form of A
is then used to solve the system of equations A * X = B.
This is the blocked version of the algorithm, calling Level 3 BLAS.
Parameters
UPLO
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
On entry, the hermitian matrix A. If UPLO = 'U', the leading
N-by-N upper triangular part of A contains the upper
triangular part of the matrix A, and the strictly lower
triangular part of A is not referenced. If UPLO = 'L', the
leading N-by-N lower triangular part of A contains the lower
triangular part of the matrix A, and the strictly upper
triangular part of A is not referenced.
On exit, L is stored below (or above) the subdiaonal blocks,
when UPLO is 'L' (or 'U').
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
TB
TB is COMPLEX*16 array, dimension (LTB)
On exit, details of the LU factorization of the band matrix.
LTB
LTB is INTEGER
The size of the array TB. LTB >= 4*N, internally
used to select NB such that LTB >= (3*NB+1)*N.
If LTB = -1, then a workspace query is assumed; the
routine only calculates the optimal size of LTB,
returns this value as the first entry of TB, and
no error message related to LTB is issued by XERBLA.
IPIV
IPIV is INTEGER array, dimension (N)
On exit, it contains the details of the interchanges, i.e.,
the row and column k of A were interchanged with the
row and column IPIV(k).
IPIV2
IPIV2 is INTEGER array, dimension (N)
On exit, it contains the details of the interchanges, i.e.,
the row and column k of T were interchanged with the
row and column IPIV(k).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side matrix B.
On exit, the solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 workspace of size LWORK
LWORK
LWORK is INTEGER
The size of WORK. LWORK >= N, internally used to select NB
such that LWORK >= N*NB.
If LWORK = -1, then a workspace query is assumed; the
routine only calculates the optimal size of the WORK array,
returns this value as the first entry of the WORK array, and
no error message related to LWORK is issued by XERBLA.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: if INFO = i, band LU factorization failed on i-th column
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
subroutine zhesv_rk (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * )
A, integer LDA, complex*16, dimension( * ) E, integer, dimension( * ) IPIV, complex*16,
dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, integer LWORK,
integer INFO)
ZHESV_RK computes the solution to system of linear equations A * X = B for SY matrices
Purpose:
ZHESV_RK computes the solution to a complex system of linear
equations A * X = B, where A is an N-by-N Hermitian matrix
and X and B are N-by-NRHS matrices.
The bounded Bunch-Kaufman (rook) diagonal pivoting method is used
to factor A as
A = P*U*D*(U**H)*(P**T), if UPLO = 'U', or
A = P*L*D*(L**H)*(P**T), if UPLO = 'L',
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.
ZHETRF_RK is called to compute the factorization of a complex
Hermitian matrix. The factored form of A is then used to solve
the system of equations A * X = B by calling BLAS3 routine ZHETRS_3.
Parameters
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
On entry, the Hermitian matrix A.
If UPLO = 'U': the leading N-by-N upper triangular part
of A contains the upper triangular part of the matrix A,
and the strictly lower triangular part of A is not
referenced.
If UPLO = 'L': the leading N-by-N lower triangular part
of A contains the lower triangular part of the matrix A,
and the strictly upper triangular part of A is not
referenced.
On exit, if INFO = 0, diagonal of the block diagonal
matrix D and factors U or L as computed by ZHETRF_RK:
a) ONLY diagonal elements of the Hermitian block diagonal
matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);
(superdiagonal (or subdiagonal) elements of D
are stored on exit in array E), and
b) If UPLO = 'U': factor U in the superdiagonal part of A.
If UPLO = 'L': factor L in the subdiagonal part of A.
For more info see the description of ZHETRF_RK routine.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
E
E is COMPLEX*16 array, dimension (N)
On exit, contains the output computed by the factorization
routine ZHETRF_RK, i.e. the superdiagonal (or subdiagonal)
elements of the Hermitian block diagonal matrix D
with 1-by-1 or 2-by-2 diagonal blocks, where
If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;
If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.
NOTE: For 1-by-1 diagonal block D(k), where
1 <= k <= N, the element E(k) is set to 0 in both
UPLO = 'U' or UPLO = 'L' cases.
For more info see the description of ZHETRF_RK routine.
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by ZHETRF_RK.
For more info see the description of ZHETRF_RK routine.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the N-by-NRHS right hand side matrix B.
On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension ( MAX(1,LWORK) ).
Work array used in the factorization stage.
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK
LWORK is INTEGER
The length of WORK. LWORK >= 1. For best performance
of factorization stage LWORK >= max(1,N*NB), where NB is
the optimal blocksize for ZHETRF_RK.
If LWORK = -1, then a workspace query is assumed;
the routine only calculates the optimal size of the WORK
array for factorization stage, returns this value as
the first entry of the WORK array, and no error message
related to LWORK is issued by XERBLA.
INFO
INFO is INTEGER
= 0: successful exit
< 0: If INFO = -k, the k-th argument had an illegal value
> 0: If INFO = k, the matrix A is singular, because:
If UPLO = 'U': column k in the upper
triangular part of A contains all zeros.
If UPLO = 'L': column k in the lower
triangular part of A contains all zeros.
Therefore D(k,k) is exactly zero, and superdiagonal
elements of column k of U (or subdiagonal elements of
column k of L ) are all zeros. The factorization has
been completed, but the block diagonal matrix D is
exactly singular, and division by zero will occur if
it is used to solve a system of equations.
NOTE: INFO only stores the first occurrence of
a singularity, any subsequent occurrence of singularity
is not stored in INFO even though the factorization
always completes.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Contributors:
December 2016, Igor Kozachenko,
Computer Science Division,
University of California, Berkeley
September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
School of Mathematics,
University of Manchester
subroutine zhesv_rook (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, *
) A, integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( * ) WORK, integer LWORK, integer INFO)
ZHESV_ROOK computes the solution to a system of linear equations A * X = B for HE matrices
using the bounded Bunch-Kaufman ('rook') diagonal pivoting method
Purpose:
ZHESV_ROOK computes the solution to a complex system of linear equations
A * X = B,
where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS
matrices.
The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used
to factor A as
A = U * D * U**T, if UPLO = 'U', or
A = L * D * L**T, if UPLO = 'L',
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.
ZHETRF_ROOK is called to compute the factorization of a complex
Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal
pivoting method.
The factored form of A is then used to solve the system
of equations A * X = B by calling ZHETRS_ROOK (uses BLAS 2).
Parameters
UPLO
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
On entry, the Hermitian matrix A. If UPLO = 'U', the leading
N-by-N upper triangular part of A contains the upper
triangular part of the matrix A, and the strictly lower
triangular part of A is not referenced. If UPLO = 'L', the
leading N-by-N lower triangular part of A contains the lower
triangular part of the matrix A, and the strictly upper
triangular part of A is not referenced.
On exit, if INFO = 0, the block diagonal matrix D and the
multipliers used to obtain the factor U or L from the
factorization A = U*D*U**H or A = L*D*L**H as computed by
ZHETRF_ROOK.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D.
If UPLO = 'U':
Only the last KB elements of IPIV are set.
If IPIV(k) > 0, then rows and columns k and IPIV(k) were
interchanged and D(k,k) is a 1-by-1 diagonal block.
If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k-1 and -IPIV(k-1) were inerchaged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
Only the first KB elements of IPIV are set.
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k+1 and -IPIV(k+1) were inerchaged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the N-by-NRHS right hand side matrix B.
On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK
LWORK is INTEGER
The length of WORK. LWORK >= 1, and for best performance
LWORK >= max(1,N*NB), where NB is the optimal blocksize for
ZHETRF_ROOK.
for LWORK < N, TRS will be done with Level BLAS 2
for LWORK >= N, TRS will be done with Level BLAS 3
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, D(i,i) is exactly zero. The factorization
has been completed, but the block diagonal matrix D is
exactly singular, so the solution could not be computed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
November 2013, Igor Kozachenko,
Computer Science Division,
University of California, Berkeley
September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
School of Mathematics,
University of Manchester.fi
subroutine zhesvx (character FACT, character UPLO, integer N, integer NRHS, complex*16,
dimension( lda, * ) A, integer LDA, complex*16, dimension( ldaf, * ) AF, integer LDAF,
integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
dimension( ldx, * ) X, integer LDX, double precision RCOND, double precision, dimension( *
) FERR, double precision, dimension( * ) BERR, complex*16, dimension( * ) WORK, integer
LWORK, double precision, dimension( * ) RWORK, integer INFO)
ZHESVX computes the solution to system of linear equations A * X = B for HE matrices
Purpose:
ZHESVX uses the diagonal pivoting factorization to compute the
solution to a complex system of linear equations A * X = B,
where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS
matrices.
Error bounds on the solution and a condition estimate are also
provided.
Description:
The following steps are performed:
1. If FACT = 'N', the diagonal pivoting method is used to factor A.
The form of the factorization is
A = U * D * U**H, if UPLO = 'U', or
A = L * D * L**H, if UPLO = 'L',
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.
2. If some D(i,i)=0, so that D is exactly singular, then the routine
returns with INFO = i. Otherwise, the factored form of A is used
to estimate the condition number of the matrix A. If the
reciprocal of the condition number is less than machine precision,
INFO = N+1 is returned as a warning, but the routine still goes on
to solve for X and compute error bounds as described below.
3. The system of equations is solved for X using the factored form
of A.
4. Iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimates
for it.
Parameters
FACT
FACT is CHARACTER*1
Specifies whether or not the factored form of A has been
supplied on entry.
= 'F': On entry, AF and IPIV contain the factored form
of A. A, AF and IPIV will not be modified.
= 'N': The matrix A will be copied to AF and factored.
UPLO
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The Hermitian matrix A. If UPLO = 'U', the leading N-by-N
upper triangular part of A contains the upper triangular part
of the matrix A, and the strictly lower triangular part of A
is not referenced. If UPLO = 'L', the leading N-by-N lower
triangular part of A contains the lower triangular part of
the matrix A, and the strictly upper triangular part of A is
not referenced.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
AF
AF is COMPLEX*16 array, dimension (LDAF,N)
If FACT = 'F', then AF is an input argument and on entry
contains the block diagonal matrix D and the multipliers used
to obtain the factor U or L from the factorization
A = U*D*U**H or A = L*D*L**H as computed by ZHETRF.
If FACT = 'N', then AF is an output argument and on exit
returns the block diagonal matrix D and the multipliers used
to obtain the factor U or L from the factorization
A = U*D*U**H or A = L*D*L**H.
LDAF
LDAF is INTEGER
The leading dimension of the array AF. LDAF >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
If FACT = 'F', then IPIV is an input argument and on entry
contains details of the interchanges and the block structure
of D, as determined by ZHETRF.
If IPIV(k) > 0, then rows and columns k and IPIV(k) were
interchanged and D(k,k) is a 1-by-1 diagonal block.
If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and
columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)
is a 2-by-2 diagonal block. If UPLO = 'L' and IPIV(k) =
IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were
interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
If FACT = 'N', then IPIV is an output argument and on exit
contains details of the interchanges and the block structure
of D, as determined by ZHETRF.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The N-by-NRHS right hand side matrix B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
RCOND
RCOND is DOUBLE PRECISION
The estimate of the reciprocal condition number of the matrix
A. If RCOND is less than the machine precision (in
particular, if RCOND = 0), the matrix is singular to working
precision. This condition is indicated by a return code of
INFO > 0.
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bound for each solution vector
X(j) (the j-th column of the solution matrix X).
If XTRUE is the true solution corresponding to X(j), FERR(j)
is an estimated upper bound for the magnitude of the largest
element in (X(j) - XTRUE) divided by the magnitude of the
largest element in X(j). The estimate is as reliable as
the estimate for RCOND, and is almost always a slight
overestimate of the true error.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector X(j) (i.e., the smallest relative change in
any element of A or B that makes X(j) an exact solution).
WORK
WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK
LWORK is INTEGER
The length of WORK. LWORK >= max(1,2*N), and for best
performance, when FACT = 'N', LWORK >= max(1,2*N,N*NB), where
NB is the optimal blocksize for ZHETRF.
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, and i is
<= N: D(i,i) is exactly zero. The factorization
has been completed but the factor D is exactly
singular, so the solution and error bounds could
not be computed. RCOND = 0 is returned.
= N+1: D is nonsingular, but RCOND is less than machine
precision, meaning that the matrix is singular
to working precision. Nevertheless, the
solution and error bounds are computed because
there are a number of situations where the
computed solution can be more accurate than the
value of RCOND would suggest.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
subroutine zhesvxx (character FACT, character UPLO, integer N, integer NRHS, complex*16,
dimension( lda, * ) A, integer LDA, complex*16, dimension( ldaf, * ) AF, integer LDAF,
integer, dimension( * ) IPIV, character EQUED, double precision, dimension( * ) S,
complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer
LDX, double precision RCOND, double precision RPVGRW, double precision, dimension( * )
BERR, integer N_ERR_BNDS, double precision, dimension( nrhs, * ) ERR_BNDS_NORM, double
precision, dimension( nrhs, * ) ERR_BNDS_COMP, integer NPARAMS, double precision,
dimension( * ) PARAMS, complex*16, dimension( * ) WORK, double precision, dimension( * )
RWORK, integer INFO)
ZHESVXX computes the solution to system of linear equations A * X = B for HE matrices
Purpose:
ZHESVXX uses the diagonal pivoting factorization to compute the
solution to a complex*16 system of linear equations A * X = B, where
A is an N-by-N Hermitian matrix and X and B are N-by-NRHS
matrices.
If requested, both normwise and maximum componentwise error bounds
are returned. ZHESVXX will return a solution with a tiny
guaranteed error (O(eps) where eps is the working machine
precision) unless the matrix is very ill-conditioned, in which
case a warning is returned. Relevant condition numbers also are
calculated and returned.
ZHESVXX accepts user-provided factorizations and equilibration
factors; see the definitions of the FACT and EQUED options.
Solving with refinement and using a factorization from a previous
ZHESVXX call will also produce a solution with either O(eps)
errors or warnings, but we cannot make that claim for general
user-provided factorizations and equilibration factors if they
differ from what ZHESVXX would itself produce.
Description:
The following steps are performed:
1. If FACT = 'E', double precision scaling factors are computed to equilibrate
the system:
diag(S)*A*diag(S) *inv(diag(S))*X = diag(S)*B
Whether or not the system will be equilibrated depends on the
scaling of the matrix A, but if equilibration is used, A is
overwritten by diag(S)*A*diag(S) and B by diag(S)*B.
2. If FACT = 'N' or 'E', the LU decomposition is used to factor
the matrix A (after equilibration if FACT = 'E') as
A = U * D * U**T, if UPLO = 'U', or
A = L * D * L**T, if UPLO = 'L',
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.
3. If some D(i,i)=0, so that D is exactly singular, then the
routine returns with INFO = i. Otherwise, the factored form of A
is used to estimate the condition number of the matrix A (see
argument RCOND). If the reciprocal of the condition number is
less than machine precision, the routine still goes on to solve
for X and compute error bounds as described below.
4. The system of equations is solved for X using the factored form
of A.
5. By default (unless PARAMS(LA_LINRX_ITREF_I) is set to zero),
the routine will use iterative refinement to try to get a small
error and error bounds. Refinement calculates the residual to at
least twice the working precision.
6. If equilibration was used, the matrix X is premultiplied by
diag(R) so that it solves the original system before
equilibration.
Some optional parameters are bundled in the PARAMS array. These
settings determine how refinement is performed, but often the
defaults are acceptable. If the defaults are acceptable, users
can pass NPARAMS = 0 which prevents the source code from accessing
the PARAMS argument.
Parameters
FACT
FACT is CHARACTER*1
Specifies whether or not the factored form of the matrix A is
supplied on entry, and if not, whether the matrix A should be
equilibrated before it is factored.
= 'F': On entry, AF and IPIV contain the factored form of A.
If EQUED is not 'N', the matrix A has been
equilibrated with scaling factors given by S.
A, AF, and IPIV are not modified.
= 'N': The matrix A will be copied to AF and factored.
= 'E': The matrix A will be equilibrated if necessary, then
copied to AF and factored.
UPLO
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N
N is INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The Hermitian matrix A. If UPLO = 'U', the leading N-by-N
upper triangular part of A contains the upper triangular
part of the matrix A, and the strictly lower triangular
part of A is not referenced. If UPLO = 'L', the leading
N-by-N lower triangular part of A contains the lower
triangular part of the matrix A, and the strictly upper
triangular part of A is not referenced.
On exit, if FACT = 'E' and EQUED = 'Y', A is overwritten by
diag(S)*A*diag(S).
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
AF
AF is COMPLEX*16 array, dimension (LDAF,N)
If FACT = 'F', then AF is an input argument and on entry
contains the block diagonal matrix D and the multipliers
used to obtain the factor U or L from the factorization A =
U*D*U**H or A = L*D*L**H as computed by ZHETRF.
If FACT = 'N', then AF is an output argument and on exit
returns the block diagonal matrix D and the multipliers
used to obtain the factor U or L from the factorization A =
U*D*U**H or A = L*D*L**H.
LDAF
LDAF is INTEGER
The leading dimension of the array AF. LDAF >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
If FACT = 'F', then IPIV is an input argument and on entry
contains details of the interchanges and the block
structure of D, as determined by ZHETRF. If IPIV(k) > 0,
then rows and columns k and IPIV(k) were interchanged and
D(k,k) is a 1-by-1 diagonal block. If UPLO = 'U' and
IPIV(k) = IPIV(k-1) < 0, then rows and columns k-1 and
-IPIV(k) were interchanged and D(k-1:k,k-1:k) is a 2-by-2
diagonal block. If UPLO = 'L' and IPIV(k) = IPIV(k+1) < 0,
then rows and columns k+1 and -IPIV(k) were interchanged
and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
If FACT = 'N', then IPIV is an output argument and on exit
contains details of the interchanges and the block
structure of D, as determined by ZHETRF.
EQUED
EQUED is CHARACTER*1
Specifies the form of equilibration that was done.
= 'N': No equilibration (always true if FACT = 'N').
= 'Y': Both row and column equilibration, i.e., A has been
replaced by diag(S) * A * diag(S).
EQUED is an input argument if FACT = 'F'; otherwise, it is an
output argument.
S
S is DOUBLE PRECISION array, dimension (N)
The scale factors for A. If EQUED = 'Y', A is multiplied on
the left and right by diag(S). S is an input argument if FACT =
'F'; otherwise, S is an output argument. If FACT = 'F' and EQUED
= 'Y', each element of S must be positive. If S is output, each
element of S is a power of the radix. If S is input, each element
of S should be a power of the radix to ensure a reliable solution
and error estimates. Scaling by powers of the radix does not cause
rounding errors unless the result underflows or overflows.
Rounding errors during scaling lead to refining with a matrix that
is not equivalent to the input matrix, producing error estimates
that may not be reliable.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the N-by-NRHS right hand side matrix B.
On exit,
if EQUED = 'N', B is not modified;
if EQUED = 'Y', B is overwritten by diag(S)*B;
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
If INFO = 0, the N-by-NRHS solution matrix X to the original
system of equations. Note that A and B are modified on exit if
EQUED .ne. 'N', and the solution to the equilibrated system is
inv(diag(S))*X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
RCOND
RCOND is DOUBLE PRECISION
Reciprocal scaled condition number. This is an estimate of the
reciprocal Skeel condition number of the matrix A after
equilibration (if done). If this is less than the machine
precision (in particular, if it is zero), the matrix is singular
to working precision. Note that the error may still be small even
if this number is very small and the matrix appears ill-
conditioned.
RPVGRW
RPVGRW is DOUBLE PRECISION
Reciprocal pivot growth. On exit, this contains the reciprocal
pivot growth factor norm(A)/norm(U). The "max absolute element"
norm is used. If this is much less than 1, then the stability of
the LU factorization of the (equilibrated) matrix A could be poor.
This also means that the solution X, estimated condition numbers,
and error bounds could be unreliable. If factorization fails with
0<INFO<=N, then this contains the reciprocal pivot growth factor
for the leading INFO columns of A.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
Componentwise relative backward error. This is the
componentwise relative backward error of each solution vector X(j)
(i.e., the smallest relative change in any element of A or B that
makes X(j) an exact solution).
N_ERR_BNDS
N_ERR_BNDS is INTEGER
Number of error bounds to return for each right hand side
and each type (normwise or componentwise). See ERR_BNDS_NORM and
ERR_BNDS_COMP below.
ERR_BNDS_NORM
ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)
For each right-hand side, this array contains information about
various error bounds and condition numbers corresponding to the
normwise relative error, which is defined as follows:
Normwise relative error in the ith solution vector:
max_j (abs(XTRUE(j,i) - X(j,i)))
------------------------------
max_j abs(X(j,i))
The array is indexed by the type of error information as described
below. There currently are up to three pieces of information
returned.
The first index in ERR_BNDS_NORM(i,:) corresponds to the ith
right-hand side.
The second index in ERR_BNDS_NORM(:,err) contains the following
three fields:
err = 1 "Trust/don't trust" boolean. Trust the answer if the
reciprocal condition number is less than the threshold
sqrt(n) * dlamch('Epsilon').
err = 2 "Guaranteed" error bound: The estimated forward error,
almost certainly within a factor of 10 of the true error
so long as the next entry is greater than the threshold
sqrt(n) * dlamch('Epsilon'). This error bound should only
be trusted if the previous boolean is true.
err = 3 Reciprocal condition number: Estimated normwise
reciprocal condition number. Compared with the threshold
sqrt(n) * dlamch('Epsilon') to determine if the error
estimate is "guaranteed". These reciprocal condition
numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
appropriately scaled matrix Z.
Let Z = S*A, where S scales each row by a power of the
radix so all absolute row sums of Z are approximately 1.
See Lapack Working Note 165 for further details and extra
cautions.
ERR_BNDS_COMP
ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)
For each right-hand side, this array contains information about
various error bounds and condition numbers corresponding to the
componentwise relative error, which is defined as follows:
Componentwise relative error in the ith solution vector:
abs(XTRUE(j,i) - X(j,i))
max_j ----------------------
abs(X(j,i))
The array is indexed by the right-hand side i (on which the
componentwise relative error depends), and the type of error
information as described below. There currently are up to three
pieces of information returned for each right-hand side. If
componentwise accuracy is not requested (PARAMS(3) = 0.0), then
ERR_BNDS_COMP is not accessed. If N_ERR_BNDS < 3, then at most
the first (:,N_ERR_BNDS) entries are returned.
The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
right-hand side.
The second index in ERR_BNDS_COMP(:,err) contains the following
three fields:
err = 1 "Trust/don't trust" boolean. Trust the answer if the
reciprocal condition number is less than the threshold
sqrt(n) * dlamch('Epsilon').
err = 2 "Guaranteed" error bound: The estimated forward error,
almost certainly within a factor of 10 of the true error
so long as the next entry is greater than the threshold
sqrt(n) * dlamch('Epsilon'). This error bound should only
be trusted if the previous boolean is true.
err = 3 Reciprocal condition number: Estimated componentwise
reciprocal condition number. Compared with the threshold
sqrt(n) * dlamch('Epsilon') to determine if the error
estimate is "guaranteed". These reciprocal condition
numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
appropriately scaled matrix Z.
Let Z = S*(A*diag(x)), where x is the solution for the
current right-hand side and S scales each row of
A*diag(x) by a power of the radix so all absolute row
sums of Z are approximately 1.
See Lapack Working Note 165 for further details and extra
cautions.
NPARAMS
NPARAMS is INTEGER
Specifies the number of parameters set in PARAMS. If <= 0, the
PARAMS array is never referenced and default values are used.
PARAMS
PARAMS is DOUBLE PRECISION array, dimension NPARAMS
Specifies algorithm parameters. If an entry is < 0.0, then
that entry will be filled with default value used for that
parameter. Only positions up to NPARAMS are accessed; defaults
are used for higher-numbered parameters.
PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative
refinement or not.
Default: 1.0D+0
= 0.0: No refinement is performed, and no error bounds are
computed.
= 1.0: Use the extra-precise refinement algorithm.
(other values are reserved for future use)
PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual
computations allowed for refinement.
Default: 10
Aggressive: Set to 100 to permit convergence using approximate
factorizations or factorizations other than LU. If
the factorization uses a technique other than
Gaussian elimination, the guarantees in
err_bnds_norm and err_bnds_comp may no longer be
trustworthy.
PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code
will attempt to find a solution with small componentwise
relative error in the double-precision algorithm. Positive
is true, 0.0 is false.
Default: 1.0 (attempt componentwise convergence)
WORK
WORK is COMPLEX*16 array, dimension (5*N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*N)
INFO
INFO is INTEGER
= 0: Successful exit. The solution to every right-hand side is
guaranteed.
< 0: If INFO = -i, the i-th argument had an illegal value
> 0 and <= N: U(INFO,INFO) is exactly zero. The factorization
has been completed, but the factor U is exactly singular, so
the solution and error bounds could not be computed. RCOND = 0
is returned.
= N+J: The solution corresponding to the Jth right-hand side is
not guaranteed. The solutions corresponding to other right-
hand sides K with K > J may not be guaranteed as well, but
only the first such right-hand side is reported. If a small
componentwise error is not requested (PARAMS(3) = 0.0) then
the Jth right-hand side is the first with a normwise error
bound that is not guaranteed (the smallest J such
that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)
the Jth right-hand side is the first with either a normwise or
componentwise error bound that is not guaranteed (the smallest
J such that either ERR_BNDS_NORM(J,1) = 0.0 or
ERR_BNDS_COMP(J,1) = 0.0). See the definition of
ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information
about all of the right-hand sides check ERR_BNDS_NORM or
ERR_BNDS_COMP.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Author
Generated automatically by Doxygen for LAPACK from the source code.