d4/db9/sporfsx_8f_source.html

 *> \brief \b SPORFSX
 *
 *  =========== DOCUMENTATION ===========
 *
 * Online html documentation available at
 *            http://www.netlib.org/lapack/explore-html/
 *
 *> \htmlonly
 *> Download SPORFSX + dependencies
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/sporfsx.f">
 *> [TGZ]</a>
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/sporfsx.f">
 *> [ZIP]</a>
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/sporfsx.f">
 *> [TXT]</a>
 *> \endhtmlonly
 *
 *  Definition:
 *  ===========
 *
 *       SUBROUTINE SPORFSX( 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 )
 *
 *       .. Scalar Arguments ..
 *       CHARACTER          UPLO, EQUED
 *       INTEGER            INFO, LDA, LDAF, LDB, LDX, N, NRHS, NPARAMS,
 *      $                   N_ERR_BNDS
 *       REAL               RCOND
 *       ..
 *       .. Array Arguments ..
 *       INTEGER            IWORK( * )
 *       REAL               A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
 *      $                   X( LDX, * ), WORK( * )
 *       REAL               S( * ), PARAMS( * ), BERR( * ),
 *      $                   ERR_BNDS_NORM( NRHS, * ),
 *      $                   ERR_BNDS_COMP( NRHS, * )
 *       ..
 *
 *
 *> \par Purpose:
 *  =============
 *>
 *> \verbatim
 *>
 *>    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.
 *> \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] UPLO
 *> \verbatim
 *>          UPLO is CHARACTER*1
 *>       = 'U':  Upper triangle of A is stored;
 *>       = 'L':  Lower triangle of A is stored.
 *> \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
 *>       = '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.
 *> \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 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.
 *> \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 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.
 *> \endverbatim
 *>
 *> \param[in] LDAF
 *> \verbatim
 *>          LDAF is INTEGER
 *>     The leading dimension of the array AF.  LDAF >= max(1,N).
 *> \endverbatim
 *>
 *> \param[in,out] S
 *> \verbatim
 *>          S is REAL array, dimension (N)
 *>     The row 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.
 *> \endverbatim
 *>
 *> \param[in] B
 *> \verbatim
 *>          B is REAL 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 REAL array, dimension (LDX,NRHS)
 *>     On entry, the solution matrix X, as computed by SGETRS.
 *>     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 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.
 *> \endverbatim
 *>
 *> \param[out] BERR
 *> \verbatim
 *>          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).
 *> \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 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.
 *> \endverbatim
 *>
 *> \param[out] ERR_BNDS_COMP
 *> \verbatim
 *>          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 .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) * 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.
 *> \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 REAL 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.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)
 *> \endverbatim
 *>
 *> \param[out] WORK
 *> \verbatim
 *>          WORK is REAL 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 April 2012
 *
 *> \ingroup realPOcomputational
 *
 *  =====================================================================
       SUBROUTINE sporfsx( 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 )
 *
 *  -- LAPACK computational routine (version 3.7.0) --
 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 *     April 2012
 *
 *     .. Scalar Arguments ..
       CHARACTER          UPLO, EQUED
       INTEGER            INFO, LDA, LDAF, LDB, LDX, N, NRHS, NPARAMS,
      $                   n_err_bnds
       REAL               RCOND
 *     ..
 *     .. Array Arguments ..
       INTEGER            IWORK( * )
       REAL               A( lda, * ), AF( ldaf, * ), B( ldb, * ),
      $                   x( ldx, * ), work( * )
       REAL               S( * ), PARAMS( * ), BERR( * ),
      $                   err_bnds_norm( nrhs, * ),
      $                   err_bnds_comp( nrhs, * )
 *     ..
 *
 *  ==================================================================
 *
 *     .. Parameters ..
       REAL               ZERO, ONE
       parameter( zero = 0.0e+0, one = 1.0e+0 )
       REAL               ITREF_DEFAULT, ITHRESH_DEFAULT,
      $                   componentwise_default
       REAL               RTHRESH_DEFAULT, DZTHRESH_DEFAULT
       parameter( itref_default = 1.0 )
       parameter( ithresh_default = 10.0 )
       parameter( componentwise_default = 1.0 )
       parameter( rthresh_default = 0.5 )
       parameter( dzthresh_default = 0.25 )
       INTEGER            LA_LINRX_ITREF_I, LA_LINRX_ITHRESH_I,
      $                   la_linrx_cwise_i
       parameter( la_linrx_itref_i = 1,
      $                   la_linrx_ithresh_i = 2 )
       parameter( la_linrx_cwise_i = 3 )
       INTEGER            LA_LINRX_TRUST_I, LA_LINRX_ERR_I,
      $                   la_linrx_rcond_i
       parameter( la_linrx_trust_i = 1, la_linrx_err_i = 2 )
       parameter( la_linrx_rcond_i = 3 )
 *     ..
 *     .. Local Scalars ..
       CHARACTER(1)       NORM
       LOGICAL            RCEQU
       INTEGER            J, PREC_TYPE, REF_TYPE
       INTEGER            N_NORMS
       REAL               ANORM, RCOND_TMP
       REAL               ILLRCOND_THRESH, ERR_LBND, CWISE_WRONG
       LOGICAL            IGNORE_CWISE
       INTEGER            ITHRESH
       REAL               RTHRESH, UNSTABLE_THRESH
 *     ..
 *     .. External Subroutines ..
       EXTERNAL           xerbla, spocon, sla_porfsx_extended
 *     ..
 *     .. Intrinsic Functions ..
       INTRINSIC          max, sqrt
 *     ..
 *     .. External Functions ..
       EXTERNAL           lsame, ilaprec
       EXTERNAL           slamch, slansy, sla_porcond
       REAL               SLAMCH, SLANSY, SLA_PORCOND
       LOGICAL            LSAME
       INTEGER            ILAPREC
 *     ..
 *     .. Executable Statements ..
 *
 *     Check the input parameters.
 *
       info = 0
       ref_type = int( itref_default )
       IF ( nparams .GE. la_linrx_itref_i ) THEN
          IF ( params( la_linrx_itref_i ) .LT. 0.0 ) THEN
             params( la_linrx_itref_i ) = itref_default
          ELSE
             ref_type = params( la_linrx_itref_i )
          END IF
       END IF
 *
 *     Set default parameters.
 *
       illrcond_thresh = REAL( N ) * SLAMCH( 'Epsilon' )
       ithresh = int( ithresh_default )
       rthresh = rthresh_default
       unstable_thresh = dzthresh_default
       ignore_cwise = componentwise_default .EQ. 0.0
 *
       IF ( nparams.GE.la_linrx_ithresh_i ) THEN
          IF ( params( la_linrx_ithresh_i ).LT.0.0 ) THEN
             params( la_linrx_ithresh_i ) = ithresh
          ELSE
             ithresh = int( params( la_linrx_ithresh_i ) )
          END IF
       END IF
       IF ( nparams.GE.la_linrx_cwise_i ) THEN
          IF ( params( la_linrx_cwise_i ).LT.0.0 ) THEN
             IF ( ignore_cwise ) THEN
                params( la_linrx_cwise_i ) = 0.0
             ELSE
                params( la_linrx_cwise_i ) = 1.0
             END IF
          ELSE
             ignore_cwise = params( la_linrx_cwise_i ) .EQ. 0.0
          END IF
       END IF
       IF ( ref_type .EQ. 0 .OR. n_err_bnds .EQ. 0 ) THEN
          n_norms = 0
       ELSE IF ( ignore_cwise ) THEN
          n_norms = 1
       ELSE
          n_norms = 2
       END IF
 *
       rcequ = lsame( equed, 'Y' )
 *
 *     Test input parameters.
 *
       IF (.NOT.lsame(uplo, 'U') .AND. .NOT.lsame(uplo, 'L')) THEN
         info = -1
       ELSE IF( .NOT.rcequ .AND. .NOT.lsame( equed, 'N' ) ) THEN
         info = -2
       ELSE IF( n.LT.0 ) THEN
         info = -3
       ELSE IF( nrhs.LT.0 ) THEN
         info = -4
       ELSE IF( lda.LT.max( 1, n ) ) THEN
         info = -6
       ELSE IF( ldaf.LT.max( 1, n ) ) THEN
         info = -8
       ELSE IF( ldb.LT.max( 1, n ) ) THEN
         info = -11
       ELSE IF( ldx.LT.max( 1, n ) ) THEN
         info = -13
       END IF
       IF( info.NE.0 ) THEN
         CALL xerbla( 'SPORFSX', -info )
         RETURN
       END IF
 *
 *     Quick return if possible.
 *
       IF( n.EQ.0 .OR. nrhs.EQ.0 ) THEN
          rcond = 1.0
          DO j = 1, nrhs
             berr( j ) = 0.0
             IF ( n_err_bnds .GE. 1 ) THEN
                err_bnds_norm( j, la_linrx_trust_i ) = 1.0
                err_bnds_comp( j, la_linrx_trust_i ) = 1.0
             END IF
             IF ( n_err_bnds .GE. 2 ) THEN
                err_bnds_norm( j, la_linrx_err_i ) = 0.0
                err_bnds_comp( j, la_linrx_err_i ) = 0.0
             END IF
             IF ( n_err_bnds .GE. 3 ) THEN
                err_bnds_norm( j, la_linrx_rcond_i ) = 1.0
                err_bnds_comp( j, la_linrx_rcond_i ) = 1.0
             END IF
          END DO
          RETURN
       END IF
 *
 *     Default to failure.
 *
       rcond = 0.0
       DO j = 1, nrhs
          berr( j ) = 1.0
          IF ( n_err_bnds .GE. 1 ) THEN
             err_bnds_norm( j, la_linrx_trust_i ) = 1.0
             err_bnds_comp( j, la_linrx_trust_i ) = 1.0
          END IF
          IF ( n_err_bnds .GE. 2 ) THEN
             err_bnds_norm( j, la_linrx_err_i ) = 1.0
             err_bnds_comp( j, la_linrx_err_i ) = 1.0
          END IF
          IF ( n_err_bnds .GE. 3 ) THEN
             err_bnds_norm( j, la_linrx_rcond_i ) = 0.0
             err_bnds_comp( j, la_linrx_rcond_i ) = 0.0
          END IF
       END DO
 *
 *     Compute the norm of A and the reciprocal of the condition
 *     number of A.
 *
       norm = 'I'
       anorm = slansy( norm, uplo, n, a, lda, work )
       CALL spocon( uplo, n, af, ldaf, anorm, rcond, work,
      $     iwork, info )
 *
 *     Perform refinement on each right-hand side
 *
       IF ( ref_type .NE. 0 ) THEN

          prec_type = ilaprec( 'D' )

          CALL sla_porfsx_extended( prec_type, uplo,  n,
      $        nrhs, a, lda, af, ldaf, rcequ, s, b,
      $        ldb, x, ldx, berr, n_norms, err_bnds_norm, err_bnds_comp,
      $        work( n+1 ), work( 1 ), work( 2*n+1 ), work( 1 ), rcond,
      $        ithresh, rthresh, unstable_thresh, ignore_cwise,
      $        info )
       END IF

       err_lbnd = max( 10.0, sqrt( REAL( N ) ) ) * slamch( 'Epsilon' )
       IF ( n_err_bnds .GE. 1 .AND. n_norms .GE. 1 ) THEN
 *
 *     Compute scaled normwise condition number cond(A*C).
 *
          IF ( rcequ ) THEN
             rcond_tmp = sla_porcond( uplo, n, a, lda, af, ldaf,
      $           -1, s, info, work, iwork )
          ELSE
             rcond_tmp = sla_porcond( uplo, n, a, lda, af, ldaf,
      $           0, s, info, work, iwork )
          END IF
          DO j = 1, nrhs
 *
 *     Cap the error at 1.0.
 *
             IF ( n_err_bnds .GE. la_linrx_err_i
      $           .AND. err_bnds_norm( j, la_linrx_err_i ) .GT. 1.0 )
      $           err_bnds_norm( j, la_linrx_err_i ) = 1.0
 *
 *     Threshold the error (see LAWN).
 *
             IF ( rcond_tmp .LT. illrcond_thresh ) THEN
                err_bnds_norm( j, la_linrx_err_i ) = 1.0
                err_bnds_norm( j, la_linrx_trust_i ) = 0.0
                IF ( info .LE. n ) info = n + j
             ELSE IF ( err_bnds_norm( j, la_linrx_err_i ) .LT. err_lbnd )
      $              THEN
                err_bnds_norm( j, la_linrx_err_i ) = err_lbnd
                err_bnds_norm( j, la_linrx_trust_i ) = 1.0
             END IF
 *
 *     Save the condition number.
 *
             IF (n_err_bnds .GE. la_linrx_rcond_i) THEN
                err_bnds_norm( j, la_linrx_rcond_i ) = rcond_tmp
             END IF
          END DO
       END IF

       IF ( n_err_bnds .GE. 1 .AND. n_norms .GE. 2 ) THEN
 *
 *     Compute componentwise condition number cond(A*diag(Y(:,J))) for
 *     each right-hand side using the current solution as an estimate of
 *     the true solution.  If the componentwise error estimate is too
 *     large, then the solution is a lousy estimate of truth and the
 *     estimated RCOND may be too optimistic.  To avoid misleading users,
 *     the inverse condition number is set to 0.0 when the estimated
 *     cwise error is at least CWISE_WRONG.
 *
          cwise_wrong = sqrt( slamch( 'Epsilon' ) )
          DO j = 1, nrhs
             IF (err_bnds_comp( j, la_linrx_err_i ) .LT. cwise_wrong )
      $     THEN
                rcond_tmp = sla_porcond( uplo, n, a, lda, af, ldaf, 1,
      $              x( 1, j ), info, work, iwork )
             ELSE
                rcond_tmp = 0.0
             END IF
 *
 *     Cap the error at 1.0.
 *
             IF ( n_err_bnds .GE. la_linrx_err_i
      $           .AND. err_bnds_comp( j, la_linrx_err_i ) .GT. 1.0 )
      $           err_bnds_comp( j, la_linrx_err_i ) = 1.0
 *
 *     Threshold the error (see LAWN).
 *
             IF ( rcond_tmp .LT. illrcond_thresh ) THEN
                err_bnds_comp( j, la_linrx_err_i ) = 1.0
                err_bnds_comp( j, la_linrx_trust_i ) = 0.0
                IF ( params( la_linrx_cwise_i ) .EQ. 1.0
      $              .AND. info.LT.n + j ) info = n + j
             ELSE IF ( err_bnds_comp( j, la_linrx_err_i )
      $              .LT. err_lbnd ) THEN
                err_bnds_comp( j, la_linrx_err_i ) = err_lbnd
                err_bnds_comp( j, la_linrx_trust_i ) = 1.0
             END IF
 *
 *     Save the condition number.
 *
             IF ( n_err_bnds .GE. la_linrx_rcond_i ) THEN
                err_bnds_comp( j, la_linrx_rcond_i ) = rcond_tmp
             END IF

          END DO
       END IF
 *
       RETURN
 *
 *     End of SPORFSX
 *
       END
sla_porcond
real function sla_porcond(UPLO, N, A, LDA, AF, LDAF, CMODE, C, INFO, WORK, IWORK)
SLA_PORCOND estimates the Skeel condition number for a symmetric positive-definite matrix...
Definition: sla_porcond.f:142

sla_porfsx_extended
subroutine sla_porfsx_extended(PREC_TYPE, UPLO, N, NRHS, A, LDA, AF, LDAF, COLEQU, C, B, LDB, Y, LDY, BERR_OUT, N_NORMS, ERR_BNDS_NORM, ERR_BNDS_COMP, RES, AYB, DY, Y_TAIL, RCOND, ITHRESH, RTHRESH, DZ_UB, IGNORE_CWISE, INFO)
SLA_PORFSX_EXTENDED improves the computed solution to a system of linear equations for symmetric or H...
Definition: sla_porfsx_extended.f:389

ilaprec
integer function ilaprec(PREC)
ILAPREC
Definition: ilaprec.f:60

xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62

spocon
subroutine spocon(UPLO, N, A, LDA, ANORM, RCOND, WORK, IWORK, INFO)
SPOCON
Definition: spocon.f:123

lsame
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55

sporfsx
subroutine sporfsx(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)
SPORFSX
Definition: sporfsx.f:396

slamch
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69

slansy
real function slansy(NORM, UPLO, N, A, LDA, WORK)
SLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix.
Definition: slansy.f:124