.TH "porfsx" 3 "Tue Jan 28 2025 00:54:31" "Version 3.12.0" "LAPACK" \" -*- nroff -*-
.ad l
.nh
.SH NAME
porfsx \- porfsx: iterative refinement, expert
.SH SYNOPSIS
.br
.PP
.SS "Functions"
.in +1c
.ti -1c
.RI "subroutine \fBcporfsx\fP (uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, info)"
.br
.RI "\fBCPORFSX\fP "
.ti -1c
.RI "subroutine \fBdporfsx\fP (uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, iwork, info)"
.br
.RI "\fBDPORFSX\fP "
.ti -1c
.RI "subroutine \fBsporfsx\fP (uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, iwork, info)"
.br
.RI "\fBSPORFSX\fP "
.ti -1c
.RI "subroutine \fBzporfsx\fP (uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, info)"
.br
.RI "\fBZPORFSX\fP "
.in -1c
.SH "Detailed Description"
.PP
.SH "Function Documentation"
.PP
.SS "subroutine cporfsx (character uplo, character equed, integer n, integer nrhs, complex, dimension( lda, * ) a, integer lda, complex, dimension( ldaf, * ) af, integer ldaf, real, dimension( * ) s, complex, dimension( ldb, * ) b, integer ldb, complex, dimension( ldx, * ) x, integer ldx, real rcond, real, dimension( * ) berr, integer n_err_bnds, real, dimension( nrhs, * ) err_bnds_norm, real, dimension( nrhs, * ) err_bnds_comp, integer nparams, real, dimension(*) params, complex, dimension( * ) work, real, dimension( * ) rwork, integer info)"
.PP
\fBCPORFSX\fP
.PP
\fBPurpose:\fP
.RS 4
.PP
.nf
CPORFSX improves the computed solution to a system of linear
equations when the coefficient matrix is Hermitian positive
definite, and provides error bounds and backward error estimates
for the solution\&. In addition to normwise error bound, the code
provides maximum componentwise error bound if possible\&. See
comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the
error bounds\&.
The original system of linear equations may have been equilibrated
before calling this routine, as described by arguments EQUED and S
below\&. In this case, the solution and error bounds returned are
for the original unequilibrated system\&.
.fi
.PP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBParameters\fP
.RS 4
\fIUPLO\fP
.PP
.nf
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored\&.
.fi
.PP
.br
\fIEQUED\fP
.PP
.nf
EQUED is CHARACTER*1
Specifies the form of equilibration that was done to A
before calling this routine\&. This is needed to compute
the solution and error bounds correctly\&.
= 'N': No equilibration
= 'Y': Both row and column equilibration, i\&.e\&., A has been
replaced by diag(S) * A * diag(S)\&.
The right hand side B has been changed accordingly\&.
.fi
.PP
.br
\fIN\fP
.PP
.nf
N is INTEGER
The order of the matrix A\&. N >= 0\&.
.fi
.PP
.br
\fINRHS\fP
.PP
.nf
NRHS is INTEGER
The number of right hand sides, i\&.e\&., the number of columns
of the matrices B and X\&. NRHS >= 0\&.
.fi
.PP
.br
\fIA\fP
.PP
.nf
A is COMPLEX 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\&.
.fi
.PP
.br
\fILDA\fP
.PP
.nf
LDA is INTEGER
The leading dimension of the array A\&. LDA >= max(1,N)\&.
.fi
.PP
.br
\fIAF\fP
.PP
.nf
AF is COMPLEX array, dimension (LDAF,N)
The triangular factor U or L from the Cholesky factorization
A = U**H*U or A = L*L**H, as computed by CPOTRF\&.
.fi
.PP
.br
\fILDAF\fP
.PP
.nf
LDAF is INTEGER
The leading dimension of the array AF\&. LDAF >= max(1,N)\&.
.fi
.PP
.br
\fIS\fP
.PP
.nf
S is REAL 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\&.
.fi
.PP
.br
\fIB\fP
.PP
.nf
B is COMPLEX array, dimension (LDB,NRHS)
The right hand side matrix B\&.
.fi
.PP
.br
\fILDB\fP
.PP
.nf
LDB is INTEGER
The leading dimension of the array B\&. LDB >= max(1,N)\&.
.fi
.PP
.br
\fIX\fP
.PP
.nf
X is COMPLEX array, dimension (LDX,NRHS)
On entry, the solution matrix X, as computed by SGETRS\&.
On exit, the improved solution matrix X\&.
.fi
.PP
.br
\fILDX\fP
.PP
.nf
LDX is INTEGER
The leading dimension of the array X\&. LDX >= max(1,N)\&.
.fi
.PP
.br
\fIRCOND\fP
.PP
.nf
RCOND is REAL
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\&.
.fi
.PP
.br
\fIBERR\fP
.PP
.nf
BERR is REAL 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)\&.
.fi
.PP
.br
\fIN_ERR_BNDS\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIERR_BNDS_NORM\fP
.PP
.nf
ERR_BNDS_NORM is REAL 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) * slamch('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) * slamch('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) * slamch('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\&.
.fi
.PP
.br
\fIERR_BNDS_COMP\fP
.PP
.nf
ERR_BNDS_COMP is REAL 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) * slamch('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) * slamch('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) * slamch('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\&.
.fi
.PP
.br
\fINPARAMS\fP
.PP
.nf
NPARAMS is INTEGER
Specifies the number of parameters set in PARAMS\&. If <= 0, the
PARAMS array is never referenced and default values are used\&.
.fi
.PP
.br
\fIPARAMS\fP
.PP
.nf
PARAMS is REAL 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\&.0
= 0\&.0: No refinement is performed, and no error bounds are
computed\&.
= 1\&.0: Use the double-precision refinement algorithm,
possibly with doubled-single computations if the
compilation environment does not support DOUBLE
PRECISION\&.
(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)
.fi
.PP
.br
\fIWORK\fP
.PP
.nf
WORK is COMPLEX array, dimension (2*N)
.fi
.PP
.br
\fIRWORK\fP
.PP
.nf
RWORK is REAL array, dimension (2*N)
.fi
.PP
.br
\fIINFO\fP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee
.PP
Univ\&. of California Berkeley
.PP
Univ\&. of Colorado Denver
.PP
NAG Ltd\&.
.RE
.PP
.SS "subroutine dporfsx (character uplo, character equed, integer n, integer nrhs, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( ldaf, * ) af, integer ldaf, double precision, dimension( * ) s, double precision, dimension( ldb, * ) b, integer ldb, double precision, dimension( ldx, * ) x, integer ldx, double precision rcond, 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, double precision, dimension( * ) work, integer, dimension( * ) iwork, integer info)"
.PP
\fBDPORFSX\fP
.PP
\fBPurpose:\fP
.RS 4
.PP
.nf
DPORFSX improves the computed solution to a system of linear
equations when the coefficient matrix is symmetric positive
definite, and provides error bounds and backward error estimates
for the solution\&. In addition to normwise error bound, the code
provides maximum componentwise error bound if possible\&. See
comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the
error bounds\&.
The original system of linear equations may have been equilibrated
before calling this routine, as described by arguments EQUED and S
below\&. In this case, the solution and error bounds returned are
for the original unequilibrated system\&.
.fi
.PP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBParameters\fP
.RS 4
\fIUPLO\fP
.PP
.nf
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored\&.
.fi
.PP
.br
\fIEQUED\fP
.PP
.nf
EQUED is CHARACTER*1
Specifies the form of equilibration that was done to A
before calling this routine\&. This is needed to compute
the solution and error bounds correctly\&.
= 'N': No equilibration
= 'Y': Both row and column equilibration, i\&.e\&., A has been
replaced by diag(S) * A * diag(S)\&.
The right hand side B has been changed accordingly\&.
.fi
.PP
.br
\fIN\fP
.PP
.nf
N is INTEGER
The order of the matrix A\&. N >= 0\&.
.fi
.PP
.br
\fINRHS\fP
.PP
.nf
NRHS is INTEGER
The number of right hand sides, i\&.e\&., the number of columns
of the matrices B and X\&. NRHS >= 0\&.
.fi
.PP
.br
\fIA\fP
.PP
.nf
A is DOUBLE PRECISION array, dimension (LDA,N)
The symmetric 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\&.
.fi
.PP
.br
\fILDA\fP
.PP
.nf
LDA is INTEGER
The leading dimension of the array A\&. LDA >= max(1,N)\&.
.fi
.PP
.br
\fIAF\fP
.PP
.nf
AF is DOUBLE PRECISION array, dimension (LDAF,N)
The triangular factor U or L from the Cholesky factorization
A = U**T*U or A = L*L**T, as computed by DPOTRF\&.
.fi
.PP
.br
\fILDAF\fP
.PP
.nf
LDAF is INTEGER
The leading dimension of the array AF\&. LDAF >= max(1,N)\&.
.fi
.PP
.br
\fIS\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIB\fP
.PP
.nf
B is DOUBLE PRECISION array, dimension (LDB,NRHS)
The right hand side matrix B\&.
.fi
.PP
.br
\fILDB\fP
.PP
.nf
LDB is INTEGER
The leading dimension of the array B\&. LDB >= max(1,N)\&.
.fi
.PP
.br
\fIX\fP
.PP
.nf
X is DOUBLE PRECISION array, dimension (LDX,NRHS)
On entry, the solution matrix X, as computed by DGETRS\&.
On exit, the improved solution matrix X\&.
.fi
.PP
.br
\fILDX\fP
.PP
.nf
LDX is INTEGER
The leading dimension of the array X\&. LDX >= max(1,N)\&.
.fi
.PP
.br
\fIRCOND\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIBERR\fP
.PP
.nf
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)\&.
.fi
.PP
.br
\fIN_ERR_BNDS\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIERR_BNDS_NORM\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIERR_BNDS_COMP\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fINPARAMS\fP
.PP
.nf
NPARAMS is INTEGER
Specifies the number of parameters set in PARAMS\&. If <= 0, the
PARAMS array is never referenced and default values are used\&.
.fi
.PP
.br
\fIPARAMS\fP
.PP
.nf
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 double-precision refinement algorithm,
possibly with doubled-single computations if the
compilation environment does not support DOUBLE
PRECISION\&.
(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)
.fi
.PP
.br
\fIWORK\fP
.PP
.nf
WORK is DOUBLE PRECISION array, dimension (4*N)
.fi
.PP
.br
\fIIWORK\fP
.PP
.nf
IWORK is INTEGER array, dimension (N)
.fi
.PP
.br
\fIINFO\fP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee
.PP
Univ\&. of California Berkeley
.PP
Univ\&. of Colorado Denver
.PP
NAG Ltd\&.
.RE
.PP
.SS "subroutine sporfsx (character uplo, character equed, integer n, integer nrhs, real, dimension( lda, * ) a, integer lda, real, dimension( ldaf, * ) af, integer ldaf, real, dimension( * ) s, real, dimension( ldb, * ) b, integer ldb, real, dimension( ldx, * ) x, integer ldx, real rcond, real, dimension( * ) berr, integer n_err_bnds, real, dimension( nrhs, * ) err_bnds_norm, real, dimension( nrhs, * ) err_bnds_comp, integer nparams, real, dimension( * ) params, real, dimension( * ) work, integer, dimension( * ) iwork, integer info)"
.PP
\fBSPORFSX\fP
.PP
\fBPurpose:\fP
.RS 4
.PP
.nf
SPORFSX improves the computed solution to a system of linear
equations when the coefficient matrix is symmetric positive
definite, and provides error bounds and backward error estimates
for the solution\&. In addition to normwise error bound, the code
provides maximum componentwise error bound if possible\&. See
comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the
error bounds\&.
The original system of linear equations may have been equilibrated
before calling this routine, as described by arguments EQUED and S
below\&. In this case, the solution and error bounds returned are
for the original unequilibrated system\&.
.fi
.PP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBParameters\fP
.RS 4
\fIUPLO\fP
.PP
.nf
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored\&.
.fi
.PP
.br
\fIEQUED\fP
.PP
.nf
EQUED is CHARACTER*1
Specifies the form of equilibration that was done to A
before calling this routine\&. This is needed to compute
the solution and error bounds correctly\&.
= 'N': No equilibration
= 'Y': Both row and column equilibration, i\&.e\&., A has been
replaced by diag(S) * A * diag(S)\&.
The right hand side B has been changed accordingly\&.
.fi
.PP
.br
\fIN\fP
.PP
.nf
N is INTEGER
The order of the matrix A\&. N >= 0\&.
.fi
.PP
.br
\fINRHS\fP
.PP
.nf
NRHS is INTEGER
The number of right hand sides, i\&.e\&., the number of columns
of the matrices B and X\&. NRHS >= 0\&.
.fi
.PP
.br
\fIA\fP
.PP
.nf
A is REAL array, dimension (LDA,N)
The symmetric 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\&.
.fi
.PP
.br
\fILDA\fP
.PP
.nf
LDA is INTEGER
The leading dimension of the array A\&. LDA >= max(1,N)\&.
.fi
.PP
.br
\fIAF\fP
.PP
.nf
AF is REAL array, dimension (LDAF,N)
The triangular factor U or L from the Cholesky factorization
A = U**T*U or A = L*L**T, as computed by SPOTRF\&.
.fi
.PP
.br
\fILDAF\fP
.PP
.nf
LDAF is INTEGER
The leading dimension of the array AF\&. LDAF >= max(1,N)\&.
.fi
.PP
.br
\fIS\fP
.PP
.nf
S is REAL 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\&.
.fi
.PP
.br
\fIB\fP
.PP
.nf
B is REAL array, dimension (LDB,NRHS)
The right hand side matrix B\&.
.fi
.PP
.br
\fILDB\fP
.PP
.nf
LDB is INTEGER
The leading dimension of the array B\&. LDB >= max(1,N)\&.
.fi
.PP
.br
\fIX\fP
.PP
.nf
X is REAL array, dimension (LDX,NRHS)
On entry, the solution matrix X, as computed by SGETRS\&.
On exit, the improved solution matrix X\&.
.fi
.PP
.br
\fILDX\fP
.PP
.nf
LDX is INTEGER
The leading dimension of the array X\&. LDX >= max(1,N)\&.
.fi
.PP
.br
\fIRCOND\fP
.PP
.nf
RCOND is REAL
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\&.
.fi
.PP
.br
\fIBERR\fP
.PP
.nf
BERR is REAL 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)\&.
.fi
.PP
.br
\fIN_ERR_BNDS\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIERR_BNDS_NORM\fP
.PP
.nf
ERR_BNDS_NORM is REAL 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) * slamch('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) * slamch('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) * slamch('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\&.
.fi
.PP
.br
\fIERR_BNDS_COMP\fP
.PP
.nf
ERR_BNDS_COMP is REAL 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) * slamch('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) * slamch('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) * slamch('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\&.
.fi
.PP
.br
\fINPARAMS\fP
.PP
.nf
NPARAMS is INTEGER
Specifies the number of parameters set in PARAMS\&. If <= 0, the
PARAMS array is never referenced and default values are used\&.
.fi
.PP
.br
\fIPARAMS\fP
.PP
.nf
PARAMS is REAL 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\&.0
= 0\&.0: No refinement is performed, and no error bounds are
computed\&.
= 1\&.0: Use the double-precision refinement algorithm,
possibly with doubled-single computations if the
compilation environment does not support DOUBLE
PRECISION\&.
(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)
.fi
.PP
.br
\fIWORK\fP
.PP
.nf
WORK is REAL array, dimension (4*N)
.fi
.PP
.br
\fIIWORK\fP
.PP
.nf
IWORK is INTEGER array, dimension (N)
.fi
.PP
.br
\fIINFO\fP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee
.PP
Univ\&. of California Berkeley
.PP
Univ\&. of Colorado Denver
.PP
NAG Ltd\&.
.RE
.PP
.SS "subroutine zporfsx (character uplo, character equed, integer n, integer nrhs, complex*16, dimension( lda, * ) a, integer lda, complex*16, dimension( ldaf, * ) af, integer ldaf, double precision, dimension( * ) s, complex*16, dimension( ldb, * ) b, integer ldb, complex*16, dimension( ldx, * ) x, integer ldx, double precision rcond, 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)"
.PP
\fBZPORFSX\fP
.PP
\fBPurpose:\fP
.RS 4
.PP
.nf
ZPORFSX improves the computed solution to a system of linear
equations when the coefficient matrix is Hermitian positive
definite, and provides error bounds and backward error estimates
for the solution\&. In addition to normwise error bound, the code
provides maximum componentwise error bound if possible\&. See
comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the
error bounds\&.
The original system of linear equations may have been equilibrated
before calling this routine, as described by arguments EQUED and S
below\&. In this case, the solution and error bounds returned are
for the original unequilibrated system\&.
.fi
.PP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBParameters\fP
.RS 4
\fIUPLO\fP
.PP
.nf
UPLO is CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored\&.
.fi
.PP
.br
\fIEQUED\fP
.PP
.nf
EQUED is CHARACTER*1
Specifies the form of equilibration that was done to A
before calling this routine\&. This is needed to compute
the solution and error bounds correctly\&.
= 'N': No equilibration
= 'Y': Both row and column equilibration, i\&.e\&., A has been
replaced by diag(S) * A * diag(S)\&.
The right hand side B has been changed accordingly\&.
.fi
.PP
.br
\fIN\fP
.PP
.nf
N is INTEGER
The order of the matrix A\&. N >= 0\&.
.fi
.PP
.br
\fINRHS\fP
.PP
.nf
NRHS is INTEGER
The number of right hand sides, i\&.e\&., the number of columns
of the matrices B and X\&. NRHS >= 0\&.
.fi
.PP
.br
\fIA\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fILDA\fP
.PP
.nf
LDA is INTEGER
The leading dimension of the array A\&. LDA >= max(1,N)\&.
.fi
.PP
.br
\fIAF\fP
.PP
.nf
AF is COMPLEX*16 array, dimension (LDAF,N)
The triangular factor U or L from the Cholesky factorization
A = U**H*U or A = L*L**H, as computed by ZPOTRF\&.
.fi
.PP
.br
\fILDAF\fP
.PP
.nf
LDAF is INTEGER
The leading dimension of the array AF\&. LDAF >= max(1,N)\&.
.fi
.PP
.br
\fIS\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIB\fP
.PP
.nf
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side matrix B\&.
.fi
.PP
.br
\fILDB\fP
.PP
.nf
LDB is INTEGER
The leading dimension of the array B\&. LDB >= max(1,N)\&.
.fi
.PP
.br
\fIX\fP
.PP
.nf
X is COMPLEX*16 array, dimension (LDX,NRHS)
On entry, the solution matrix X, as computed by ZGETRS\&.
On exit, the improved solution matrix X\&.
.fi
.PP
.br
\fILDX\fP
.PP
.nf
LDX is INTEGER
The leading dimension of the array X\&. LDX >= max(1,N)\&.
.fi
.PP
.br
\fIRCOND\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIBERR\fP
.PP
.nf
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)\&.
.fi
.PP
.br
\fIN_ERR_BNDS\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIERR_BNDS_NORM\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fIERR_BNDS_COMP\fP
.PP
.nf
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\&.
.fi
.PP
.br
\fINPARAMS\fP
.PP
.nf
NPARAMS is INTEGER
Specifies the number of parameters set in PARAMS\&. If <= 0, the
PARAMS array is never referenced and default values are used\&.
.fi
.PP
.br
\fIPARAMS\fP
.PP
.nf
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 double-precision refinement algorithm,
possibly with doubled-single computations if the
compilation environment does not support DOUBLE
PRECISION\&.
(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)
.fi
.PP
.br
\fIWORK\fP
.PP
.nf
WORK is COMPLEX*16 array, dimension (2*N)
.fi
.PP
.br
\fIRWORK\fP
.PP
.nf
RWORK is DOUBLE PRECISION array, dimension (2*N)
.fi
.PP
.br
\fIINFO\fP
.PP
.nf
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\&.
.fi
.PP
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee
.PP
Univ\&. of California Berkeley
.PP
Univ\&. of Colorado Denver
.PP
NAG Ltd\&.
.RE
.PP
.SH "Author"
.PP
Generated automatically by Doxygen for LAPACK from the source code\&.