File:  [local] / rpl / lapack / lapack / zla_gerfsx_extended.f
Revision 1.5: download - view: text, annotated - select for diffs - revision graph
Mon Nov 21 20:43:13 2011 UTC (12 years, 5 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD
Mise à jour de Lapack.

    1: *> \brief \b ZLA_GERFSX_EXTENDED
    2: *
    3: *  =========== DOCUMENTATION ===========
    4: *
    5: * Online html documentation available at 
    6: *            http://www.netlib.org/lapack/explore-html/ 
    7: *
    8: *> \htmlonly
    9: *> Download ZLA_GERFSX_EXTENDED + dependencies 
   10: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zla_gerfsx_extended.f"> 
   11: *> [TGZ]</a> 
   12: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zla_gerfsx_extended.f"> 
   13: *> [ZIP]</a> 
   14: *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zla_gerfsx_extended.f"> 
   15: *> [TXT]</a>
   16: *> \endhtmlonly 
   17: *
   18: *  Definition:
   19: *  ===========
   20: *
   21: *       SUBROUTINE ZLA_GERFSX_EXTENDED( PREC_TYPE, TRANS_TYPE, N, NRHS, A,
   22: *                                       LDA, AF, LDAF, IPIV, COLEQU, C, B,
   23: *                                       LDB, Y, LDY, BERR_OUT, N_NORMS,
   24: *                                       ERRS_N, ERRS_C, RES, AYB, DY,
   25: *                                       Y_TAIL, RCOND, ITHRESH, RTHRESH,
   26: *                                       DZ_UB, IGNORE_CWISE, INFO )
   27:    28: *       .. Scalar Arguments ..
   29: *       INTEGER            INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
   30: *      $                   TRANS_TYPE, N_NORMS
   31: *       LOGICAL            COLEQU, IGNORE_CWISE
   32: *       INTEGER            ITHRESH
   33: *       DOUBLE PRECISION   RTHRESH, DZ_UB
   34: *       ..
   35: *       .. Array Arguments
   36: *       INTEGER            IPIV( * )
   37: *       COMPLEX*16         A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
   38: *      $                   Y( LDY, * ), RES( * ), DY( * ), Y_TAIL( * )
   39: *       DOUBLE PRECISION   C( * ), AYB( * ), RCOND, BERR_OUT( * ),
   40: *      $                   ERRS_N( NRHS, * ), ERRS_C( NRHS, * )
   41: *       ..
   42: *  
   43: *
   44: *> \par Purpose:
   45: *  =============
   46: *>
   47: *> \verbatim
   48: *>
   49: *> ZLA_GERFSX_EXTENDED improves the computed solution to a system of
   50: *> linear equations by performing extra-precise iterative refinement
   51: *> and provides error bounds and backward error estimates for the solution.
   52: *> This subroutine is called by ZGERFSX to perform iterative refinement.
   53: *> In addition to normwise error bound, the code provides maximum
   54: *> componentwise error bound if possible. See comments for ERRS_N
   55: *> and ERRS_C for details of the error bounds. Note that this
   56: *> subroutine is only resonsible for setting the second fields of
   57: *> ERRS_N and ERRS_C.
   58: *> \endverbatim
   59: *
   60: *  Arguments:
   61: *  ==========
   62: *
   63: *> \param[in] PREC_TYPE
   64: *> \verbatim
   65: *>          PREC_TYPE is INTEGER
   66: *>     Specifies the intermediate precision to be used in refinement.
   67: *>     The value is defined by ILAPREC(P) where P is a CHARACTER and
   68: *>     P    = 'S':  Single
   69: *>          = 'D':  Double
   70: *>          = 'I':  Indigenous
   71: *>          = 'X', 'E':  Extra
   72: *> \endverbatim
   73: *>
   74: *> \param[in] TRANS_TYPE
   75: *> \verbatim
   76: *>          TRANS_TYPE is INTEGER
   77: *>     Specifies the transposition operation on A.
   78: *>     The value is defined by ILATRANS(T) where T is a CHARACTER and
   79: *>     T    = 'N':  No transpose
   80: *>          = 'T':  Transpose
   81: *>          = 'C':  Conjugate transpose
   82: *> \endverbatim
   83: *>
   84: *> \param[in] N
   85: *> \verbatim
   86: *>          N is INTEGER
   87: *>     The number of linear equations, i.e., the order of the
   88: *>     matrix A.  N >= 0.
   89: *> \endverbatim
   90: *>
   91: *> \param[in] NRHS
   92: *> \verbatim
   93: *>          NRHS is INTEGER
   94: *>     The number of right-hand-sides, i.e., the number of columns of the
   95: *>     matrix B.
   96: *> \endverbatim
   97: *>
   98: *> \param[in] A
   99: *> \verbatim
  100: *>          A is COMPLEX*16 array, dimension (LDA,N)
  101: *>     On entry, the N-by-N matrix A.
  102: *> \endverbatim
  103: *>
  104: *> \param[in] LDA
  105: *> \verbatim
  106: *>          LDA is INTEGER
  107: *>     The leading dimension of the array A.  LDA >= max(1,N).
  108: *> \endverbatim
  109: *>
  110: *> \param[in] AF
  111: *> \verbatim
  112: *>          AF is COMPLEX*16 array, dimension (LDAF,N)
  113: *>     The factors L and U from the factorization
  114: *>     A = P*L*U as computed by ZGETRF.
  115: *> \endverbatim
  116: *>
  117: *> \param[in] LDAF
  118: *> \verbatim
  119: *>          LDAF is INTEGER
  120: *>     The leading dimension of the array AF.  LDAF >= max(1,N).
  121: *> \endverbatim
  122: *>
  123: *> \param[in] IPIV
  124: *> \verbatim
  125: *>          IPIV is INTEGER array, dimension (N)
  126: *>     The pivot indices from the factorization A = P*L*U
  127: *>     as computed by ZGETRF; row i of the matrix was interchanged
  128: *>     with row IPIV(i).
  129: *> \endverbatim
  130: *>
  131: *> \param[in] COLEQU
  132: *> \verbatim
  133: *>          COLEQU is LOGICAL
  134: *>     If .TRUE. then column equilibration was done to A before calling
  135: *>     this routine. This is needed to compute the solution and error
  136: *>     bounds correctly.
  137: *> \endverbatim
  138: *>
  139: *> \param[in] C
  140: *> \verbatim
  141: *>          C is DOUBLE PRECISION array, dimension (N)
  142: *>     The column scale factors for A. If COLEQU = .FALSE., C
  143: *>     is not accessed. If C is input, each element of C should be a power
  144: *>     of the radix to ensure a reliable solution and error estimates.
  145: *>     Scaling by powers of the radix does not cause rounding errors unless
  146: *>     the result underflows or overflows. Rounding errors during scaling
  147: *>     lead to refining with a matrix that is not equivalent to the
  148: *>     input matrix, producing error estimates that may not be
  149: *>     reliable.
  150: *> \endverbatim
  151: *>
  152: *> \param[in] B
  153: *> \verbatim
  154: *>          B is COMPLEX*16 array, dimension (LDB,NRHS)
  155: *>     The right-hand-side matrix B.
  156: *> \endverbatim
  157: *>
  158: *> \param[in] LDB
  159: *> \verbatim
  160: *>          LDB is INTEGER
  161: *>     The leading dimension of the array B.  LDB >= max(1,N).
  162: *> \endverbatim
  163: *>
  164: *> \param[in,out] Y
  165: *> \verbatim
  166: *>          Y is COMPLEX*16 array, dimension (LDY,NRHS)
  167: *>     On entry, the solution matrix X, as computed by ZGETRS.
  168: *>     On exit, the improved solution matrix Y.
  169: *> \endverbatim
  170: *>
  171: *> \param[in] LDY
  172: *> \verbatim
  173: *>          LDY is INTEGER
  174: *>     The leading dimension of the array Y.  LDY >= max(1,N).
  175: *> \endverbatim
  176: *>
  177: *> \param[out] BERR_OUT
  178: *> \verbatim
  179: *>          BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)
  180: *>     On exit, BERR_OUT(j) contains the componentwise relative backward
  181: *>     error for right-hand-side j from the formula
  182: *>         max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
  183: *>     where abs(Z) is the componentwise absolute value of the matrix
  184: *>     or vector Z. This is computed by ZLA_LIN_BERR.
  185: *> \endverbatim
  186: *>
  187: *> \param[in] N_NORMS
  188: *> \verbatim
  189: *>          N_NORMS is INTEGER
  190: *>     Determines which error bounds to return (see ERRS_N
  191: *>     and ERRS_C).
  192: *>     If N_NORMS >= 1 return normwise error bounds.
  193: *>     If N_NORMS >= 2 return componentwise error bounds.
  194: *> \endverbatim
  195: *>
  196: *> \param[in,out] ERRS_N
  197: *> \verbatim
  198: *>          ERRS_N is DOUBLE PRECISION array, dimension
  199: *>                    (NRHS, N_ERR_BNDS)
  200: *>     For each right-hand side, this array contains information about
  201: *>     various error bounds and condition numbers corresponding to the
  202: *>     normwise relative error, which is defined as follows:
  203: *>
  204: *>     Normwise relative error in the ith solution vector:
  205: *>             max_j (abs(XTRUE(j,i) - X(j,i)))
  206: *>            ------------------------------
  207: *>                  max_j abs(X(j,i))
  208: *>
  209: *>     The array is indexed by the type of error information as described
  210: *>     below. There currently are up to three pieces of information
  211: *>     returned.
  212: *>
  213: *>     The first index in ERRS_N(i,:) corresponds to the ith
  214: *>     right-hand side.
  215: *>
  216: *>     The second index in ERRS_N(:,err) contains the following
  217: *>     three fields:
  218: *>     err = 1 "Trust/don't trust" boolean. Trust the answer if the
  219: *>              reciprocal condition number is less than the threshold
  220: *>              sqrt(n) * slamch('Epsilon').
  221: *>
  222: *>     err = 2 "Guaranteed" error bound: The estimated forward error,
  223: *>              almost certainly within a factor of 10 of the true error
  224: *>              so long as the next entry is greater than the threshold
  225: *>              sqrt(n) * slamch('Epsilon'). This error bound should only
  226: *>              be trusted if the previous boolean is true.
  227: *>
  228: *>     err = 3  Reciprocal condition number: Estimated normwise
  229: *>              reciprocal condition number.  Compared with the threshold
  230: *>              sqrt(n) * slamch('Epsilon') to determine if the error
  231: *>              estimate is "guaranteed". These reciprocal condition
  232: *>              numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
  233: *>              appropriately scaled matrix Z.
  234: *>              Let Z = S*A, where S scales each row by a power of the
  235: *>              radix so all absolute row sums of Z are approximately 1.
  236: *>
  237: *>     This subroutine is only responsible for setting the second field
  238: *>     above.
  239: *>     See Lapack Working Note 165 for further details and extra
  240: *>     cautions.
  241: *> \endverbatim
  242: *>
  243: *> \param[in,out] ERRS_C
  244: *> \verbatim
  245: *>          ERRS_C is DOUBLE PRECISION array, dimension
  246: *>                    (NRHS, N_ERR_BNDS)
  247: *>     For each right-hand side, this array contains information about
  248: *>     various error bounds and condition numbers corresponding to the
  249: *>     componentwise relative error, which is defined as follows:
  250: *>
  251: *>     Componentwise relative error in the ith solution vector:
  252: *>                    abs(XTRUE(j,i) - X(j,i))
  253: *>             max_j ----------------------
  254: *>                         abs(X(j,i))
  255: *>
  256: *>     The array is indexed by the right-hand side i (on which the
  257: *>     componentwise relative error depends), and the type of error
  258: *>     information as described below. There currently are up to three
  259: *>     pieces of information returned for each right-hand side. If
  260: *>     componentwise accuracy is not requested (PARAMS(3) = 0.0), then
  261: *>     ERRS_C is not accessed.  If N_ERR_BNDS .LT. 3, then at most
  262: *>     the first (:,N_ERR_BNDS) entries are returned.
  263: *>
  264: *>     The first index in ERRS_C(i,:) corresponds to the ith
  265: *>     right-hand side.
  266: *>
  267: *>     The second index in ERRS_C(:,err) contains the following
  268: *>     three fields:
  269: *>     err = 1 "Trust/don't trust" boolean. Trust the answer if the
  270: *>              reciprocal condition number is less than the threshold
  271: *>              sqrt(n) * slamch('Epsilon').
  272: *>
  273: *>     err = 2 "Guaranteed" error bound: The estimated forward error,
  274: *>              almost certainly within a factor of 10 of the true error
  275: *>              so long as the next entry is greater than the threshold
  276: *>              sqrt(n) * slamch('Epsilon'). This error bound should only
  277: *>              be trusted if the previous boolean is true.
  278: *>
  279: *>     err = 3  Reciprocal condition number: Estimated componentwise
  280: *>              reciprocal condition number.  Compared with the threshold
  281: *>              sqrt(n) * slamch('Epsilon') to determine if the error
  282: *>              estimate is "guaranteed". These reciprocal condition
  283: *>              numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
  284: *>              appropriately scaled matrix Z.
  285: *>              Let Z = S*(A*diag(x)), where x is the solution for the
  286: *>              current right-hand side and S scales each row of
  287: *>              A*diag(x) by a power of the radix so all absolute row
  288: *>              sums of Z are approximately 1.
  289: *>
  290: *>     This subroutine is only responsible for setting the second field
  291: *>     above.
  292: *>     See Lapack Working Note 165 for further details and extra
  293: *>     cautions.
  294: *> \endverbatim
  295: *>
  296: *> \param[in] RES
  297: *> \verbatim
  298: *>          RES is COMPLEX*16 array, dimension (N)
  299: *>     Workspace to hold the intermediate residual.
  300: *> \endverbatim
  301: *>
  302: *> \param[in] AYB
  303: *> \verbatim
  304: *>          AYB is DOUBLE PRECISION array, dimension (N)
  305: *>     Workspace.
  306: *> \endverbatim
  307: *>
  308: *> \param[in] DY
  309: *> \verbatim
  310: *>          DY is COMPLEX*16 array, dimension (N)
  311: *>     Workspace to hold the intermediate solution.
  312: *> \endverbatim
  313: *>
  314: *> \param[in] Y_TAIL
  315: *> \verbatim
  316: *>          Y_TAIL is COMPLEX*16 array, dimension (N)
  317: *>     Workspace to hold the trailing bits of the intermediate solution.
  318: *> \endverbatim
  319: *>
  320: *> \param[in] RCOND
  321: *> \verbatim
  322: *>          RCOND is DOUBLE PRECISION
  323: *>     Reciprocal scaled condition number.  This is an estimate of the
  324: *>     reciprocal Skeel condition number of the matrix A after
  325: *>     equilibration (if done).  If this is less than the machine
  326: *>     precision (in particular, if it is zero), the matrix is singular
  327: *>     to working precision.  Note that the error may still be small even
  328: *>     if this number is very small and the matrix appears ill-
  329: *>     conditioned.
  330: *> \endverbatim
  331: *>
  332: *> \param[in] ITHRESH
  333: *> \verbatim
  334: *>          ITHRESH is INTEGER
  335: *>     The maximum number of residual computations allowed for
  336: *>     refinement. The default is 10. For 'aggressive' set to 100 to
  337: *>     permit convergence using approximate factorizations or
  338: *>     factorizations other than LU. If the factorization uses a
  339: *>     technique other than Gaussian elimination, the guarantees in
  340: *>     ERRS_N and ERRS_C may no longer be trustworthy.
  341: *> \endverbatim
  342: *>
  343: *> \param[in] RTHRESH
  344: *> \verbatim
  345: *>          RTHRESH is DOUBLE PRECISION
  346: *>     Determines when to stop refinement if the error estimate stops
  347: *>     decreasing. Refinement will stop when the next solution no longer
  348: *>     satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is
  349: *>     the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The
  350: *>     default value is 0.5. For 'aggressive' set to 0.9 to permit
  351: *>     convergence on extremely ill-conditioned matrices. See LAWN 165
  352: *>     for more details.
  353: *> \endverbatim
  354: *>
  355: *> \param[in] DZ_UB
  356: *> \verbatim
  357: *>          DZ_UB is DOUBLE PRECISION
  358: *>     Determines when to start considering componentwise convergence.
  359: *>     Componentwise convergence is only considered after each component
  360: *>     of the solution Y is stable, which we definte as the relative
  361: *>     change in each component being less than DZ_UB. The default value
  362: *>     is 0.25, requiring the first bit to be stable. See LAWN 165 for
  363: *>     more details.
  364: *> \endverbatim
  365: *>
  366: *> \param[in] IGNORE_CWISE
  367: *> \verbatim
  368: *>          IGNORE_CWISE is LOGICAL
  369: *>     If .TRUE. then ignore componentwise convergence. Default value
  370: *>     is .FALSE..
  371: *> \endverbatim
  372: *>
  373: *> \param[out] INFO
  374: *> \verbatim
  375: *>          INFO is INTEGER
  376: *>       = 0:  Successful exit.
  377: *>       < 0:  if INFO = -i, the ith argument to ZGETRS had an illegal
  378: *>             value
  379: *> \endverbatim
  380: *
  381: *  Authors:
  382: *  ========
  383: *
  384: *> \author Univ. of Tennessee 
  385: *> \author Univ. of California Berkeley 
  386: *> \author Univ. of Colorado Denver 
  387: *> \author NAG Ltd. 
  388: *
  389: *> \date November 2011
  390: *
  391: *> \ingroup complex16GEcomputational
  392: *
  393: *  =====================================================================
  394:       SUBROUTINE ZLA_GERFSX_EXTENDED( PREC_TYPE, TRANS_TYPE, N, NRHS, A,
  395:      $                                LDA, AF, LDAF, IPIV, COLEQU, C, B,
  396:      $                                LDB, Y, LDY, BERR_OUT, N_NORMS,
  397:      $                                ERRS_N, ERRS_C, RES, AYB, DY,
  398:      $                                Y_TAIL, RCOND, ITHRESH, RTHRESH,
  399:      $                                DZ_UB, IGNORE_CWISE, INFO )
  400: *
  401: *  -- LAPACK computational routine (version 3.4.0) --
  402: *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
  403: *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
  404: *     November 2011
  405: *
  406: *     .. Scalar Arguments ..
  407:       INTEGER            INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
  408:      $                   TRANS_TYPE, N_NORMS
  409:       LOGICAL            COLEQU, IGNORE_CWISE
  410:       INTEGER            ITHRESH
  411:       DOUBLE PRECISION   RTHRESH, DZ_UB
  412: *     ..
  413: *     .. Array Arguments
  414:       INTEGER            IPIV( * )
  415:       COMPLEX*16         A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
  416:      $                   Y( LDY, * ), RES( * ), DY( * ), Y_TAIL( * )
  417:       DOUBLE PRECISION   C( * ), AYB( * ), RCOND, BERR_OUT( * ),
  418:      $                   ERRS_N( NRHS, * ), ERRS_C( NRHS, * )
  419: *     ..
  420: *
  421: *  =====================================================================
  422: *
  423: *     .. Local Scalars ..
  424:       CHARACTER          TRANS
  425:       INTEGER            CNT, I, J,  X_STATE, Z_STATE, Y_PREC_STATE
  426:       DOUBLE PRECISION   YK, DYK, YMIN, NORMY, NORMX, NORMDX, DXRAT,
  427:      $                   DZRAT, PREVNORMDX, PREV_DZ_Z, DXRATMAX,
  428:      $                   DZRATMAX, DX_X, DZ_Z, FINAL_DX_X, FINAL_DZ_Z,
  429:      $                   EPS, HUGEVAL, INCR_THRESH
  430:       LOGICAL            INCR_PREC
  431:       COMPLEX*16         ZDUM
  432: *     ..
  433: *     .. Parameters ..
  434:       INTEGER            UNSTABLE_STATE, WORKING_STATE, CONV_STATE,
  435:      $                   NOPROG_STATE, BASE_RESIDUAL, EXTRA_RESIDUAL,
  436:      $                   EXTRA_Y
  437:       PARAMETER          ( UNSTABLE_STATE = 0, WORKING_STATE = 1,
  438:      $                   CONV_STATE = 2,
  439:      $                   NOPROG_STATE = 3 )
  440:       PARAMETER          ( BASE_RESIDUAL = 0, EXTRA_RESIDUAL = 1,
  441:      $                   EXTRA_Y = 2 )
  442:       INTEGER            FINAL_NRM_ERR_I, FINAL_CMP_ERR_I, BERR_I
  443:       INTEGER            RCOND_I, NRM_RCOND_I, NRM_ERR_I, CMP_RCOND_I
  444:       INTEGER            CMP_ERR_I, PIV_GROWTH_I
  445:       PARAMETER          ( FINAL_NRM_ERR_I = 1, FINAL_CMP_ERR_I = 2,
  446:      $                   BERR_I = 3 )
  447:       PARAMETER          ( RCOND_I = 4, NRM_RCOND_I = 5, NRM_ERR_I = 6 )
  448:       PARAMETER          ( CMP_RCOND_I = 7, CMP_ERR_I = 8,
  449:      $                   PIV_GROWTH_I = 9 )
  450:       INTEGER            LA_LINRX_ITREF_I, LA_LINRX_ITHRESH_I,
  451:      $                   LA_LINRX_CWISE_I
  452:       PARAMETER          ( LA_LINRX_ITREF_I = 1,
  453:      $                   LA_LINRX_ITHRESH_I = 2 )
  454:       PARAMETER          ( LA_LINRX_CWISE_I = 3 )
  455:       INTEGER            LA_LINRX_TRUST_I, LA_LINRX_ERR_I,
  456:      $                   LA_LINRX_RCOND_I
  457:       PARAMETER          ( LA_LINRX_TRUST_I = 1, LA_LINRX_ERR_I = 2 )
  458:       PARAMETER          ( LA_LINRX_RCOND_I = 3 )
  459: *     ..
  460: *     .. External Subroutines ..
  461:       EXTERNAL           ZAXPY, ZCOPY, ZGETRS, ZGEMV, BLAS_ZGEMV_X,
  462:      $                   BLAS_ZGEMV2_X, ZLA_GEAMV, ZLA_WWADDW, DLAMCH,
  463:      $                   CHLA_TRANSTYPE, ZLA_LIN_BERR
  464:       DOUBLE PRECISION   DLAMCH
  465:       CHARACTER          CHLA_TRANSTYPE
  466: *     ..
  467: *     .. Intrinsic Functions ..
  468:       INTRINSIC          ABS, MAX, MIN
  469: *     ..
  470: *     .. Statement Functions ..
  471:       DOUBLE PRECISION   CABS1
  472: *     ..
  473: *     .. Statement Function Definitions ..
  474:       CABS1( ZDUM ) = ABS( DBLE( ZDUM ) ) + ABS( DIMAG( ZDUM ) )
  475: *     ..
  476: *     .. Executable Statements ..
  477: *
  478:       IF ( INFO.NE.0 ) RETURN
  479:       TRANS = CHLA_TRANSTYPE(TRANS_TYPE)
  480:       EPS = DLAMCH( 'Epsilon' )
  481:       HUGEVAL = DLAMCH( 'Overflow' )
  482: *     Force HUGEVAL to Inf
  483:       HUGEVAL = HUGEVAL * HUGEVAL
  484: *     Using HUGEVAL may lead to spurious underflows.
  485:       INCR_THRESH = DBLE( N ) * EPS
  486: *
  487:       DO J = 1, NRHS
  488:          Y_PREC_STATE = EXTRA_RESIDUAL
  489:          IF ( Y_PREC_STATE .EQ. EXTRA_Y ) THEN
  490:             DO I = 1, N
  491:                Y_TAIL( I ) = 0.0D+0
  492:             END DO
  493:          END IF
  494: 
  495:          DXRAT = 0.0D+0
  496:          DXRATMAX = 0.0D+0
  497:          DZRAT = 0.0D+0
  498:          DZRATMAX = 0.0D+0
  499:          FINAL_DX_X = HUGEVAL
  500:          FINAL_DZ_Z = HUGEVAL
  501:          PREVNORMDX = HUGEVAL
  502:          PREV_DZ_Z = HUGEVAL
  503:          DZ_Z = HUGEVAL
  504:          DX_X = HUGEVAL
  505: 
  506:          X_STATE = WORKING_STATE
  507:          Z_STATE = UNSTABLE_STATE
  508:          INCR_PREC = .FALSE.
  509: 
  510:          DO CNT = 1, ITHRESH
  511: *
  512: *         Compute residual RES = B_s - op(A_s) * Y,
  513: *             op(A) = A, A**T, or A**H depending on TRANS (and type).
  514: *
  515:             CALL ZCOPY( N, B( 1, J ), 1, RES, 1 )
  516:             IF ( Y_PREC_STATE .EQ. BASE_RESIDUAL ) THEN
  517:                CALL ZGEMV( TRANS, N, N, (-1.0D+0,0.0D+0), A, LDA,
  518:      $              Y( 1, J ), 1, (1.0D+0,0.0D+0), RES, 1)
  519:             ELSE IF (Y_PREC_STATE .EQ. EXTRA_RESIDUAL) THEN
  520:                CALL BLAS_ZGEMV_X( TRANS_TYPE, N, N, (-1.0D+0,0.0D+0), A,
  521:      $              LDA, Y( 1, J ), 1, (1.0D+0,0.0D+0),
  522:      $              RES, 1, PREC_TYPE )
  523:             ELSE
  524:                CALL BLAS_ZGEMV2_X( TRANS_TYPE, N, N, (-1.0D+0,0.0D+0),
  525:      $              A, LDA, Y(1, J), Y_TAIL, 1, (1.0D+0,0.0D+0), RES, 1,
  526:      $              PREC_TYPE)
  527:             END IF
  528: 
  529: !         XXX: RES is no longer needed.
  530:             CALL ZCOPY( N, RES, 1, DY, 1 )
  531:             CALL ZGETRS( TRANS, N, 1, AF, LDAF, IPIV, DY, N, INFO )
  532: *
  533: *         Calculate relative changes DX_X, DZ_Z and ratios DXRAT, DZRAT.
  534: *
  535:             NORMX = 0.0D+0
  536:             NORMY = 0.0D+0
  537:             NORMDX = 0.0D+0
  538:             DZ_Z = 0.0D+0
  539:             YMIN = HUGEVAL
  540: *
  541:             DO I = 1, N
  542:                YK = CABS1( Y( I, J ) )
  543:                DYK = CABS1( DY( I ) )
  544: 
  545:                IF ( YK .NE. 0.0D+0 ) THEN
  546:                   DZ_Z = MAX( DZ_Z, DYK / YK )
  547:                ELSE IF ( DYK .NE. 0.0D+0 ) THEN
  548:                   DZ_Z = HUGEVAL
  549:                END IF
  550: 
  551:                YMIN = MIN( YMIN, YK )
  552: 
  553:                NORMY = MAX( NORMY, YK )
  554: 
  555:                IF ( COLEQU ) THEN
  556:                   NORMX = MAX( NORMX, YK * C( I ) )
  557:                   NORMDX = MAX( NORMDX, DYK * C( I ) )
  558:                ELSE
  559:                   NORMX = NORMY
  560:                   NORMDX = MAX(NORMDX, DYK)
  561:                END IF
  562:             END DO
  563: 
  564:             IF ( NORMX .NE. 0.0D+0 ) THEN
  565:                DX_X = NORMDX / NORMX
  566:             ELSE IF ( NORMDX .EQ. 0.0D+0 ) THEN
  567:                DX_X = 0.0D+0
  568:             ELSE
  569:                DX_X = HUGEVAL
  570:             END IF
  571: 
  572:             DXRAT = NORMDX / PREVNORMDX
  573:             DZRAT = DZ_Z / PREV_DZ_Z
  574: *
  575: *         Check termination criteria
  576: *
  577:             IF (.NOT.IGNORE_CWISE
  578:      $           .AND. YMIN*RCOND .LT. INCR_THRESH*NORMY
  579:      $           .AND. Y_PREC_STATE .LT. EXTRA_Y )
  580:      $           INCR_PREC = .TRUE.
  581: 
  582:             IF ( X_STATE .EQ. NOPROG_STATE .AND. DXRAT .LE. RTHRESH )
  583:      $           X_STATE = WORKING_STATE
  584:             IF ( X_STATE .EQ. WORKING_STATE ) THEN
  585:                IF (DX_X .LE. EPS) THEN
  586:                   X_STATE = CONV_STATE
  587:                ELSE IF ( DXRAT .GT. RTHRESH ) THEN
  588:                   IF ( Y_PREC_STATE .NE. EXTRA_Y ) THEN
  589:                      INCR_PREC = .TRUE.
  590:                   ELSE
  591:                      X_STATE = NOPROG_STATE
  592:                   END IF
  593:                ELSE
  594:                   IF ( DXRAT .GT. DXRATMAX ) DXRATMAX = DXRAT
  595:                END IF
  596:                IF ( X_STATE .GT. WORKING_STATE ) FINAL_DX_X = DX_X
  597:             END IF
  598: 
  599:             IF ( Z_STATE .EQ. UNSTABLE_STATE .AND. DZ_Z .LE. DZ_UB )
  600:      $           Z_STATE = WORKING_STATE
  601:             IF ( Z_STATE .EQ. NOPROG_STATE .AND. DZRAT .LE. RTHRESH )
  602:      $           Z_STATE = WORKING_STATE
  603:             IF ( Z_STATE .EQ. WORKING_STATE ) THEN
  604:                IF ( DZ_Z .LE. EPS ) THEN
  605:                   Z_STATE = CONV_STATE
  606:                ELSE IF ( DZ_Z .GT. DZ_UB ) THEN
  607:                   Z_STATE = UNSTABLE_STATE
  608:                   DZRATMAX = 0.0D+0
  609:                   FINAL_DZ_Z = HUGEVAL
  610:                ELSE IF ( DZRAT .GT. RTHRESH ) THEN
  611:                   IF ( Y_PREC_STATE .NE. EXTRA_Y ) THEN
  612:                      INCR_PREC = .TRUE.
  613:                   ELSE
  614:                      Z_STATE = NOPROG_STATE
  615:                   END IF
  616:                ELSE
  617:                   IF ( DZRAT .GT. DZRATMAX ) DZRATMAX = DZRAT
  618:                END IF
  619:                IF ( Z_STATE .GT. WORKING_STATE ) FINAL_DZ_Z = DZ_Z
  620:             END IF
  621: *
  622: *           Exit if both normwise and componentwise stopped working,
  623: *           but if componentwise is unstable, let it go at least two
  624: *           iterations.
  625: *
  626:             IF ( X_STATE.NE.WORKING_STATE ) THEN
  627:                IF ( IGNORE_CWISE ) GOTO 666
  628:                IF ( Z_STATE.EQ.NOPROG_STATE .OR. Z_STATE.EQ.CONV_STATE )
  629:      $              GOTO 666
  630:                IF ( Z_STATE.EQ.UNSTABLE_STATE .AND. CNT.GT.1 ) GOTO 666
  631:             END IF
  632: 
  633:             IF ( INCR_PREC ) THEN
  634:                INCR_PREC = .FALSE.
  635:                Y_PREC_STATE = Y_PREC_STATE + 1
  636:                DO I = 1, N
  637:                   Y_TAIL( I ) = 0.0D+0
  638:                END DO
  639:             END IF
  640: 
  641:             PREVNORMDX = NORMDX
  642:             PREV_DZ_Z = DZ_Z
  643: *
  644: *           Update soluton.
  645: *
  646:             IF ( Y_PREC_STATE .LT. EXTRA_Y ) THEN
  647:                CALL ZAXPY( N, (1.0D+0,0.0D+0), DY, 1, Y(1,J), 1 )
  648:             ELSE
  649:                CALL ZLA_WWADDW( N, Y( 1, J ), Y_TAIL, DY )
  650:             END IF
  651: 
  652:          END DO
  653: *        Target of "IF (Z_STOP .AND. X_STOP)".  Sun's f77 won't EXIT.
  654:  666     CONTINUE
  655: *
  656: *     Set final_* when cnt hits ithresh
  657: *
  658:          IF ( X_STATE .EQ. WORKING_STATE ) FINAL_DX_X = DX_X
  659:          IF ( Z_STATE .EQ. WORKING_STATE ) FINAL_DZ_Z = DZ_Z
  660: *
  661: *     Compute error bounds
  662: *
  663:          IF (N_NORMS .GE. 1) THEN
  664:             ERRS_N( J, LA_LINRX_ERR_I ) = FINAL_DX_X / (1 - DXRATMAX)
  665: 
  666:          END IF
  667:          IF ( N_NORMS .GE. 2 ) THEN
  668:             ERRS_C( J, LA_LINRX_ERR_I ) = FINAL_DZ_Z / (1 - DZRATMAX)
  669:          END IF
  670: *
  671: *     Compute componentwise relative backward error from formula
  672: *         max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
  673: *     where abs(Z) is the componentwise absolute value of the matrix
  674: *     or vector Z.
  675: *
  676: *        Compute residual RES = B_s - op(A_s) * Y,
  677: *            op(A) = A, A**T, or A**H depending on TRANS (and type).
  678: *
  679:          CALL ZCOPY( N, B( 1, J ), 1, RES, 1 )
  680:          CALL ZGEMV( TRANS, N, N, (-1.0D+0,0.0D+0), A, LDA, Y(1,J), 1,
  681:      $        (1.0D+0,0.0D+0), RES, 1 )
  682: 
  683:          DO I = 1, N
  684:             AYB( I ) = CABS1( B( I, J ) )
  685:          END DO
  686: *
  687: *     Compute abs(op(A_s))*abs(Y) + abs(B_s).
  688: *
  689:          CALL ZLA_GEAMV ( TRANS_TYPE, N, N, 1.0D+0,
  690:      $        A, LDA, Y(1, J), 1, 1.0D+0, AYB, 1 )
  691: 
  692:          CALL ZLA_LIN_BERR ( N, N, 1, RES, AYB, BERR_OUT( J ) )
  693: *
  694: *     End of loop for each RHS.
  695: *
  696:       END DO
  697: *
  698:       RETURN
  699:       END

CVSweb interface <joel.bertrand@systella.fr>