diff options
author | julie <julielangou@users.noreply.github.com> | 2011-10-06 06:53:11 +0000 |
---|---|---|
committer | julie <julielangou@users.noreply.github.com> | 2011-10-06 06:53:11 +0000 |
commit | e1d39294aee16fa6db9ba079b14442358217db71 (patch) | |
tree | 30e5aa04c1f6596991fda5334f63dfb9b8027849 /SRC/dgerfsx.f | |
parent | 5fe0466a14e395641f4f8a300ecc9dcb8058081b (diff) | |
download | lapack-e1d39294aee16fa6db9ba079b14442358217db71.tar.gz lapack-e1d39294aee16fa6db9ba079b14442358217db71.tar.bz2 lapack-e1d39294aee16fa6db9ba079b14442358217db71.zip |
Integrating Doxygen in comments
Diffstat (limited to 'SRC/dgerfsx.f')
-rw-r--r-- | SRC/dgerfsx.f | 712 |
1 files changed, 426 insertions, 286 deletions
diff --git a/SRC/dgerfsx.f b/SRC/dgerfsx.f index a33c5bfa..37b66716 100644 --- a/SRC/dgerfsx.f +++ b/SRC/dgerfsx.f @@ -1,18 +1,435 @@ +*> \brief \b DGERFSX +* +* =========== DOCUMENTATION =========== +* +* Online html documentation available at +* http://www.netlib.org/lapack/explore-html/ +* +* Definition +* ========== +* +* SUBROUTINE DGERFSX( TRANS, EQUED, N, NRHS, A, LDA, AF, LDAF, IPIV, +* R, C, B, LDB, X, LDX, RCOND, BERR, N_ERR_BNDS, +* ERR_BNDS_NORM, ERR_BNDS_COMP, NPARAMS, PARAMS, +* WORK, IWORK, INFO ) +* +* .. Scalar Arguments .. +* CHARACTER TRANS, EQUED +* INTEGER INFO, LDA, LDAF, LDB, LDX, N, NRHS, NPARAMS, +* $ N_ERR_BNDS +* DOUBLE PRECISION RCOND +* .. +* .. Array Arguments .. +* INTEGER IPIV( * ), IWORK( * ) +* DOUBLE PRECISION A( LDA, * ), AF( LDAF, * ), B( LDB, * ), +* $ X( LDX , * ), WORK( * ) +* DOUBLE PRECISION R( * ), C( * ), PARAMS( * ), BERR( * ), +* $ ERR_BNDS_NORM( NRHS, * ), +* $ ERR_BNDS_COMP( NRHS, * ) +* .. +* +* Purpose +* ======= +* +*>\details \b Purpose: +*>\verbatim +*> Purpose +*> ======= +*> +*> DGERFSX improves the computed solution to a system of linear +*> equations 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, R +*> and C below. In this case, the solution and error bounds returned +*> are for the original unequilibrated system. +*> +*>\endverbatim +* +* Arguments +* ========= +* +*> \verbatim +*> 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. +*> \endverbatim +*> +*> \param[in] TRANS +*> \verbatim +*> TRANS is CHARACTER*1 +*> Specifies the form of the system of equations: +*> = 'N': A * X = B (No transpose) +*> = 'T': A**T * X = B (Transpose) +*> = 'C': A**H * X = B (Conjugate transpose = Transpose) +*> \endverbatim +*> +*> \param[in] EQUED +*> \verbatim +*> 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 +*> = 'R': Row equilibration, i.e., A has been premultiplied by +*> diag(R). +*> = 'C': Column equilibration, i.e., A has been postmultiplied +*> by diag(C). +*> = 'B': Both row and column equilibration, i.e., A has been +*> replaced by diag(R) * A * diag(C). +*> The right hand side B has been changed accordingly. +*> \endverbatim +*> +*> \param[in] N +*> \verbatim +*> N is INTEGER +*> The order of the matrix A. N >= 0. +*> \endverbatim +*> +*> \param[in] NRHS +*> \verbatim +*> NRHS is INTEGER +*> The number of right hand sides, i.e., the number of columns +*> of the matrices B and X. NRHS >= 0. +*> \endverbatim +*> +*> \param[in] A +*> \verbatim +*> A is DOUBLE PRECISION array, dimension (LDA,N) +*> The original N-by-N matrix A. +*> \endverbatim +*> +*> \param[in] LDA +*> \verbatim +*> LDA is INTEGER +*> The leading dimension of the array A. LDA >= max(1,N). +*> \endverbatim +*> +*> \param[in] AF +*> \verbatim +*> AF is DOUBLE PRECISION array, dimension (LDAF,N) +*> The factors L and U from the factorization A = P*L*U +*> as computed by DGETRF. +*> \endverbatim +*> +*> \param[in] LDAF +*> \verbatim +*> LDAF is INTEGER +*> The leading dimension of the array AF. LDAF >= max(1,N). +*> \endverbatim +*> +*> \param[in] IPIV +*> \verbatim +*> IPIV is INTEGER array, dimension (N) +*> The pivot indices from DGETRF; for 1<=i<=N, row i of the +*> matrix was interchanged with row IPIV(i). +*> \endverbatim +*> +*> \param[in] R +*> \verbatim +*> R is DOUBLE PRECISION array, dimension (N) +*> The row scale factors for A. If EQUED = 'R' or 'B', A is +*> multiplied on the left by diag(R); if EQUED = 'N' or 'C', R +*> is not accessed. +*> If R is accessed, each element of R 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. +*> \endverbatim +*> +*> \param[in] C +*> \verbatim +*> C is DOUBLE PRECISION array, dimension (N) +*> The column scale factors for A. If EQUED = 'C' or 'B', A is +*> multiplied on the right by diag(C); if EQUED = 'N' or 'R', C +*> is not accessed. +*> If C is accessed, each element of C 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. +*> \endverbatim +*> +*> \param[in] B +*> \verbatim +*> B is DOUBLE PRECISION array, dimension (LDB,NRHS) +*> The right hand side matrix B. +*> \endverbatim +*> +*> \param[in] LDB +*> \verbatim +*> LDB is INTEGER +*> The leading dimension of the array B. LDB >= max(1,N). +*> \endverbatim +*> +*> \param[in,out] X +*> \verbatim +*> 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. +*> \endverbatim +*> +*> \param[in] LDX +*> \verbatim +*> LDX is INTEGER +*> The leading dimension of the array X. LDX >= max(1,N). +*> \endverbatim +*> +*> \param[out] RCOND +*> \verbatim +*> 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. +*> \endverbatim +*> +*> \param[out] BERR +*> \verbatim +*> 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). +*> \endverbatim +*> +*> \param[in] N_ERR_BNDS +*> \verbatim +*> 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. +*> \endverbatim +*> +*> \param[out] ERR_BNDS_NORM +*> \verbatim +*> 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: +*> \endverbatim +*> \verbatim +*> Normwise relative error in the ith solution vector: +*> max_j (abs(XTRUE(j,i) - X(j,i))) +*> ------------------------------ +*> max_j abs(X(j,i)) +*> \endverbatim +*> \verbatim +*> The array is indexed by the type of error information as described +*> below. There currently are up to three pieces of information +*> returned. +*> \endverbatim +*> \verbatim +*> The first index in ERR_BNDS_NORM(i,:) corresponds to the ith +*> right-hand side. +*> \endverbatim +*> \verbatim +*> 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'). +*> \endverbatim +*> \verbatim +*> 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. +*> \endverbatim +*> \verbatim +*> 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. +*> \endverbatim +*> \verbatim +*> See Lapack Working Note 165 for further details and extra +*> cautions. +*> \endverbatim +*> +*> \param[out] ERR_BNDS_COMP +*> \verbatim +*> 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: +*> \endverbatim +*> \verbatim +*> Componentwise relative error in the ith solution vector: +*> abs(XTRUE(j,i) - X(j,i)) +*> max_j ---------------------- +*> abs(X(j,i)) +*> \endverbatim +*> \verbatim +*> 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 .LT. 3, then at most +*> the first (:,N_ERR_BNDS) entries are returned. +*> \endverbatim +*> \verbatim +*> The first index in ERR_BNDS_COMP(i,:) corresponds to the ith +*> right-hand side. +*> \endverbatim +*> \verbatim +*> 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'). +*> \endverbatim +*> \verbatim +*> 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. +*> \endverbatim +*> \verbatim +*> 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. +*> \endverbatim +*> \verbatim +*> See Lapack Working Note 165 for further details and extra +*> cautions. +*> \endverbatim +*> +*> \param[in] NPARAMS +*> \verbatim +*> NPARAMS is INTEGER +*> Specifies the number of parameters set in PARAMS. If .LE. 0, the +*> PARAMS array is never referenced and default values are used. +*> \endverbatim +*> +*> \param[in,out] PARAMS +*> \verbatim +*> PARAMS is / output) DOUBLE PRECISION array, dimension (NPARAMS) +*> Specifies algorithm parameters. If an entry is .LT. 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. +*> \endverbatim +*> \verbatim +*> 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) +*> \endverbatim +*> \verbatim +*> 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. +*> \endverbatim +*> \verbatim +*> 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) +*> \endverbatim +*> +*> \param[out] WORK +*> \verbatim +*> WORK is DOUBLE PRECISION array, dimension (4*N) +*> \endverbatim +*> +*> \param[out] IWORK +*> \verbatim +*> IWORK is INTEGER array, dimension (N) +*> \endverbatim +*> +*> \param[out] INFO +*> \verbatim +*> 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. +*> \endverbatim +*> +* +* Authors +* ======= +* +*> \author Univ. of Tennessee +*> \author Univ. of California Berkeley +*> \author Univ. of Colorado Denver +*> \author NAG Ltd. +* +*> \date November 2011 +* +*> \ingroup doubleGEcomputational +* +* ===================================================================== SUBROUTINE DGERFSX( TRANS, EQUED, N, NRHS, A, LDA, AF, LDAF, IPIV, $ R, C, B, LDB, X, LDX, RCOND, BERR, N_ERR_BNDS, $ ERR_BNDS_NORM, ERR_BNDS_COMP, NPARAMS, PARAMS, $ WORK, IWORK, INFO ) * -* -- LAPACK routine (version 3.2.2) -- -* -- Contributed by James Demmel, Deaglan Halligan, Yozo Hida and -- -* -- Jason Riedy of Univ. of California Berkeley. -- -* -- June 2010 -- -* -* -- LAPACK is a software package provided by Univ. of Tennessee, -- -* -- Univ. of California Berkeley and NAG Ltd. -- +* -- LAPACK computational routine (version 3.2.2) -- +* -- LAPACK is a software package provided by Univ. of Tennessee, -- +* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- +* November 2011 * - IMPLICIT NONE -* .. * .. Scalar Arguments .. CHARACTER TRANS, EQUED INTEGER INFO, LDA, LDAF, LDB, LDX, N, NRHS, NPARAMS, @@ -28,283 +445,6 @@ $ ERR_BNDS_COMP( NRHS, * ) * .. * -* Purpose -* ======= -* -* DGERFSX improves the computed solution to a system of linear -* equations 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, R -* and C below. In this case, the solution and error bounds returned -* are for the original unequilibrated system. -* -* Arguments -* ========= -* -* 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. -* -* TRANS (input) CHARACTER*1 -* Specifies the form of the system of equations: -* = 'N': A * X = B (No transpose) -* = 'T': A**T * X = B (Transpose) -* = 'C': A**H * X = B (Conjugate transpose = Transpose) -* -* EQUED (input) 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 -* = 'R': Row equilibration, i.e., A has been premultiplied by -* diag(R). -* = 'C': Column equilibration, i.e., A has been postmultiplied -* by diag(C). -* = 'B': Both row and column equilibration, i.e., A has been -* replaced by diag(R) * A * diag(C). -* The right hand side B has been changed accordingly. -* -* N (input) INTEGER -* The order of the matrix A. N >= 0. -* -* NRHS (input) INTEGER -* The number of right hand sides, i.e., the number of columns -* of the matrices B and X. NRHS >= 0. -* -* A (input) DOUBLE PRECISION array, dimension (LDA,N) -* The original N-by-N matrix A. -* -* LDA (input) INTEGER -* The leading dimension of the array A. LDA >= max(1,N). -* -* AF (input) DOUBLE PRECISION array, dimension (LDAF,N) -* The factors L and U from the factorization A = P*L*U -* as computed by DGETRF. -* -* LDAF (input) INTEGER -* The leading dimension of the array AF. LDAF >= max(1,N). -* -* IPIV (input) INTEGER array, dimension (N) -* The pivot indices from DGETRF; for 1<=i<=N, row i of the -* matrix was interchanged with row IPIV(i). -* -* R (input) DOUBLE PRECISION array, dimension (N) -* The row scale factors for A. If EQUED = 'R' or 'B', A is -* multiplied on the left by diag(R); if EQUED = 'N' or 'C', R -* is not accessed. -* If R is accessed, each element of R 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. -* -* C (input) DOUBLE PRECISION array, dimension (N) -* The column scale factors for A. If EQUED = 'C' or 'B', A is -* multiplied on the right by diag(C); if EQUED = 'N' or 'R', C -* is not accessed. -* If C is accessed, each element of C 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 (input) DOUBLE PRECISION array, dimension (LDB,NRHS) -* The right hand side matrix B. -* -* LDB (input) INTEGER -* The leading dimension of the array B. LDB >= max(1,N). -* -* X (input/output) DOUBLE PRECISION array, dimension (LDX,NRHS) -* On entry, the solution matrix X, as computed by DGETRS. -* On exit, the improved solution matrix X. -* -* LDX (input) INTEGER -* The leading dimension of the array X. LDX >= max(1,N). -* -* RCOND (output) 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. -* -* BERR (output) 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 (input) 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 (output) 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 (output) 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 .LT. 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 (input) INTEGER -* Specifies the number of parameters set in PARAMS. If .LE. 0, the -* PARAMS array is never referenced and default values are used. -* -* PARAMS (input / output) DOUBLE PRECISION array, dimension (NPARAMS) -* Specifies algorithm parameters. If an entry is .LT. 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) -* -* WORK (workspace) DOUBLE PRECISION array, dimension (4*N) -* -* IWORK (workspace) INTEGER array, dimension (N) -* -* INFO (output) 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. -* * ================================================================== * * .. Parameters .. |