LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
zebchvxx.f
Go to the documentation of this file.
00001 *> \brief \b ZEBCHVXX
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *  Definition:
00009 *  ===========
00010 *
00011 *      SUBROUTINE ZEBCHVXX( THRESH, PATH )
00012 *
00013 *     .. Scalar Arguments ..
00014 *      DOUBLE PRECISION  THRESH
00015 *      CHARACTER*3       PATH
00016 *       ..
00017 *
00018 *  Purpose
00019 *  ======
00020 *
00021 *> \details \b Purpose:
00022 *> \verbatim
00023 *>
00024 *>  ZEBCHVXX will run Z**SVXX on a series of Hilbert matrices and then
00025 *>  compare the error bounds returned by Z**SVXX to see if the returned
00026 *>  answer indeed falls within those bounds.
00027 *>
00028 *>  Eight test ratios will be computed.  The tests will pass if they are .LT.
00029 *>  THRESH.  There are two cases that are determined by 1 / (SQRT( N ) * EPS).
00030 *>  If that value is .LE. to the component wise reciprocal condition number,
00031 *>  it uses the guaranteed case, other wise it uses the unguaranteed case.
00032 *>
00033 *>  Test ratios:
00034 *>     Let Xc be X_computed and Xt be X_truth.
00035 *>     The norm used is the infinity norm.
00036 *>
00037 *>     Let A be the guaranteed case and B be the unguaranteed case.
00038 *>
00039 *>       1. Normwise guaranteed forward error bound.
00040 *>       A: norm ( abs( Xc - Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and
00041 *>          ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS.
00042 *>          If these conditions are met, the test ratio is set to be
00043 *>          ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10).  Otherwise it is 1/EPS.
00044 *>       B: For this case, CGESVXX should just return 1.  If it is less than
00045 *>          one, treat it the same as in 1A.  Otherwise it fails. (Set test
00046 *>          ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?)
00047 *>
00048 *>       2. Componentwise guaranteed forward error bound.
00049 *>       A: norm ( abs( Xc(j) - Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i )
00050 *>          for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS.
00051 *>          If these conditions are met, the test ratio is set to be
00052 *>          ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10).  Otherwise it is 1/EPS.
00053 *>       B: Same as normwise test ratio.
00054 *>
00055 *>       3. Backwards error.
00056 *>       A: The test ratio is set to BERR/EPS.
00057 *>       B: Same test ratio.
00058 *>
00059 *>       4. Reciprocal condition number.
00060 *>       A: A condition number is computed with Xt and compared with the one
00061 *>          returned from CGESVXX.  Let RCONDc be the RCOND returned by CGESVXX
00062 *>          and RCONDt be the RCOND from the truth value.  Test ratio is set to
00063 *>          MAX(RCONDc/RCONDt, RCONDt/RCONDc).
00064 *>       B: Test ratio is set to 1 / (EPS * RCONDc).
00065 *>
00066 *>       5. Reciprocal normwise condition number.
00067 *>       A: The test ratio is set to
00068 *>          MAX(ERRBND( *, nwise_i, cond_i ) / NCOND, NCOND / ERRBND( *, nwise_i, cond_i )).
00069 *>       B: Test ratio is set to 1 / (EPS * ERRBND( *, nwise_i, cond_i )).
00070 *>
00071 *>       6. Reciprocal componentwise condition number.
00072 *>       A: Test ratio is set to
00073 *>          MAX(ERRBND( *, cwise_i, cond_i ) / CCOND, CCOND / ERRBND( *, cwise_i, cond_i )).
00074 *>       B: Test ratio is set to 1 / (EPS * ERRBND( *, cwise_i, cond_i )).
00075 *>
00076 *>     .. Parameters ..
00077 *>     NMAX is determined by the largest number in the inverse of the hilbert
00078 *>     matrix.  Precision is exhausted when the largest entry in it is greater
00079 *>     than 2 to the power of the number of bits in the fraction of the data
00080 *>     type used plus one, which is 24 for single precision.
00081 *>     NMAX should be 6 for single and 11 for double.
00082 *> \endverbatim
00083 *
00084 *  Authors:
00085 *  ========
00086 *
00087 *> \author Univ. of Tennessee 
00088 *> \author Univ. of California Berkeley 
00089 *> \author Univ. of Colorado Denver 
00090 *> \author NAG Ltd. 
00091 *
00092 *> \date November 2011
00093 *
00094 *> \ingroup complex16_lin
00095 *
00096 *  =====================================================================
00097       SUBROUTINE ZEBCHVXX( THRESH, PATH )
00098       IMPLICIT NONE
00099 *     .. Scalar Arguments ..
00100       DOUBLE PRECISION  THRESH
00101       CHARACTER*3       PATH
00102 
00103       INTEGER            NMAX, NPARAMS, NERRBND, NTESTS, KL, KU
00104       PARAMETER          (NMAX = 10, NPARAMS = 2, NERRBND = 3,
00105      $                    NTESTS = 6)
00106 
00107 *     .. Local Scalars ..
00108       INTEGER            N, NRHS, INFO, I ,J, k, NFAIL, LDA,
00109      $                   N_AUX_TESTS, LDAB, LDAFB
00110       CHARACTER          FACT, TRANS, UPLO, EQUED
00111       CHARACTER*2        C2
00112       CHARACTER(3)       NGUAR, CGUAR
00113       LOGICAL            printed_guide
00114       DOUBLE PRECISION   NCOND, CCOND, M, NORMDIF, NORMT, RCOND,
00115      $                   RNORM, RINORM, SUMR, SUMRI, EPS,
00116      $                   BERR(NMAX), RPVGRW, ORCOND,
00117      $                   CWISE_ERR, NWISE_ERR, CWISE_BND, NWISE_BND,
00118      $                   CWISE_RCOND, NWISE_RCOND,
00119      $                   CONDTHRESH, ERRTHRESH
00120       COMPLEX*16         ZDUM
00121 
00122 *     .. Local Arrays ..
00123       DOUBLE PRECISION   TSTRAT(NTESTS), RINV(NMAX), PARAMS(NPARAMS),
00124      $                   S(NMAX),R(NMAX),C(NMAX),RWORK(3*NMAX),
00125      $                   DIFF(NMAX, NMAX),
00126      $                   ERRBND_N(NMAX*3), ERRBND_C(NMAX*3)
00127       INTEGER            IPIV(NMAX)
00128       COMPLEX*16         A(NMAX,NMAX),INVHILB(NMAX,NMAX),X(NMAX,NMAX),
00129      $                   WORK(NMAX*3*5), AF(NMAX, NMAX),B(NMAX, NMAX),
00130      $                   ACOPY(NMAX, NMAX),
00131      $                   AB( (NMAX-1)+(NMAX-1)+1, NMAX ),
00132      $                   ABCOPY( (NMAX-1)+(NMAX-1)+1, NMAX ),
00133      $                   AFB( 2*(NMAX-1)+(NMAX-1)+1, NMAX )
00134 
00135 *     .. External Functions ..
00136       DOUBLE PRECISION   DLAMCH
00137 
00138 *     .. External Subroutines ..
00139       EXTERNAL           ZLAHILB, ZGESVXX, ZPOSVXX, ZSYSVXX,
00140      $                   ZGBSVXX, ZLACPY, LSAMEN
00141       LOGICAL            LSAMEN
00142 
00143 *     .. Intrinsic Functions ..
00144       INTRINSIC          SQRT, MAX, ABS, DBLE, DIMAG
00145 
00146 *     .. Statement Functions ..
00147       DOUBLE PRECISION   CABS1
00148 
00149 *     .. Statement Function Definitions ..
00150       CABS1( ZDUM ) = ABS( DBLE( ZDUM ) ) + ABS( DIMAG( ZDUM ) )
00151 
00152 *     .. Parameters ..
00153       INTEGER            NWISE_I, CWISE_I
00154       PARAMETER          (NWISE_I = 1, CWISE_I = 1)
00155       INTEGER            BND_I, COND_I
00156       PARAMETER          (BND_I = 2, COND_I = 3)
00157 
00158 *  Create the loop to test out the Hilbert matrices
00159 
00160       FACT = 'E'
00161       UPLO = 'U'
00162       TRANS = 'N'
00163       EQUED = 'N'
00164       EPS = DLAMCH('Epsilon')
00165       NFAIL = 0
00166       N_AUX_TESTS = 0
00167       LDA = NMAX
00168       LDAB = (NMAX-1)+(NMAX-1)+1
00169       LDAFB = 2*(NMAX-1)+(NMAX-1)+1
00170       C2 = PATH( 2: 3 )
00171 
00172 *     Main loop to test the different Hilbert Matrices.
00173 
00174       printed_guide = .false.
00175 
00176       DO N = 1 , NMAX
00177          PARAMS(1) = -1
00178          PARAMS(2) = -1
00179 
00180          KL = N-1
00181          KU = N-1
00182          NRHS = n
00183          M = MAX(SQRT(DBLE(N)), 10.0D+0)
00184 
00185 *        Generate the Hilbert matrix, its inverse, and the
00186 *        right hand side, all scaled by the LCM(1,..,2N-1).
00187          CALL ZLAHILB(N, N, A, LDA, INVHILB, LDA, B,
00188      $        LDA, WORK, INFO, PATH)
00189 
00190 *        Copy A into ACOPY.
00191          CALL ZLACPY('ALL', N, N, A, NMAX, ACOPY, NMAX)
00192 
00193 *        Store A in band format for GB tests
00194          DO J = 1, N
00195             DO I = 1, KL+KU+1
00196                AB( I, J ) = (0.0D+0,0.0D+0)
00197             END DO
00198          END DO
00199          DO J = 1, N
00200             DO I = MAX( 1, J-KU ), MIN( N, J+KL )
00201                AB( KU+1+I-J, J ) = A( I, J )
00202             END DO
00203          END DO
00204 
00205 *        Copy AB into ABCOPY.
00206          DO J = 1, N
00207             DO I = 1, KL+KU+1
00208                ABCOPY( I, J ) = (0.0D+0,0.0D+0)
00209             END DO
00210          END DO
00211          CALL ZLACPY('ALL', KL+KU+1, N, AB, LDAB, ABCOPY, LDAB)
00212 
00213 *        Call Z**SVXX with default PARAMS and N_ERR_BND = 3.
00214          IF ( LSAMEN( 2, C2, 'SY' ) ) THEN
00215             CALL ZSYSVXX(FACT, UPLO, N, NRHS, ACOPY, LDA, AF, LDA,
00216      $           IPIV, EQUED, S, B, LDA, X, LDA, ORCOND,
00217      $           RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS,
00218      $           PARAMS, WORK, RWORK, INFO)
00219          ELSE IF ( LSAMEN( 2, C2, 'PO' ) ) THEN
00220             CALL ZPOSVXX(FACT, UPLO, N, NRHS, ACOPY, LDA, AF, LDA,
00221      $           EQUED, S, B, LDA, X, LDA, ORCOND,
00222      $           RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS,
00223      $           PARAMS, WORK, RWORK, INFO)
00224          ELSE IF ( LSAMEN( 2, C2, 'HE' ) ) THEN
00225             CALL ZHESVXX(FACT, UPLO, N, NRHS, ACOPY, LDA, AF, LDA,
00226      $           IPIV, EQUED, S, B, LDA, X, LDA, ORCOND,
00227      $           RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS,
00228      $           PARAMS, WORK, RWORK, INFO)
00229          ELSE IF ( LSAMEN( 2, C2, 'GB' ) ) THEN
00230             CALL ZGBSVXX(FACT, TRANS, N, KL, KU, NRHS, ABCOPY,
00231      $           LDAB, AFB, LDAFB, IPIV, EQUED, R, C, B,
00232      $           LDA, X, LDA, ORCOND, RPVGRW, BERR, NERRBND,
00233      $           ERRBND_N, ERRBND_C, NPARAMS, PARAMS, WORK, RWORK,
00234      $           INFO)
00235          ELSE
00236             CALL ZGESVXX(FACT, TRANS, N, NRHS, ACOPY, LDA, AF, LDA,
00237      $           IPIV, EQUED, R, C, B, LDA, X, LDA, ORCOND,
00238      $           RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS,
00239      $           PARAMS, WORK, RWORK, INFO)
00240          END IF
00241 
00242          N_AUX_TESTS = N_AUX_TESTS + 1
00243          IF (ORCOND .LT. EPS) THEN
00244 !        Either factorization failed or the matrix is flagged, and 1 <=
00245 !        INFO <= N+1. We don't decide based on rcond anymore.
00246 !            IF (INFO .EQ. 0 .OR. INFO .GT. N+1) THEN
00247 !               NFAIL = NFAIL + 1
00248 !               WRITE (*, FMT=8000) N, INFO, ORCOND, RCOND
00249 !            END IF
00250          ELSE
00251 !        Either everything succeeded (INFO == 0) or some solution failed
00252 !        to converge (INFO > N+1).
00253             IF (INFO .GT. 0 .AND. INFO .LE. N+1) THEN
00254                NFAIL = NFAIL + 1
00255                WRITE (*, FMT=8000) C2, N, INFO, ORCOND, RCOND
00256             END IF
00257          END IF
00258 
00259 *        Calculating the difference between Z**SVXX's X and the true X.
00260          DO I = 1,N
00261             DO J =1,NRHS
00262                DIFF(I,J) = X(I,J) - INVHILB(I,J)
00263             END DO
00264          END DO
00265 
00266 *        Calculating the RCOND
00267          RNORM = 0
00268          RINORM = 0
00269          IF ( LSAMEN( 2, C2, 'PO' ) .OR. LSAMEN( 2, C2, 'SY' ) .OR.
00270      $        LSAMEN( 2, C2, 'HE' ) ) THEN
00271             DO I = 1, N
00272                SUMR = 0
00273                SUMRI = 0
00274                DO J = 1, N
00275                   SUMR = SUMR + S(I) * CABS1(A(I,J)) * S(J)
00276                   SUMRI = SUMRI + CABS1(INVHILB(I, J)) / (S(J) * S(I))
00277                END DO
00278                RNORM = MAX(RNORM,SUMR)
00279                RINORM = MAX(RINORM,SUMRI)
00280             END DO
00281          ELSE IF ( LSAMEN( 2, C2, 'GE' ) .OR. LSAMEN( 2, C2, 'GB' ) )
00282      $           THEN
00283             DO I = 1, N
00284                SUMR = 0
00285                SUMRI = 0
00286                DO J = 1, N
00287                   SUMR = SUMR + R(I) * CABS1(A(I,J)) * C(J)
00288                   SUMRI = SUMRI + CABS1(INVHILB(I, J)) / (R(J) * C(I))
00289                END DO
00290                RNORM = MAX(RNORM,SUMR)
00291                RINORM = MAX(RINORM,SUMRI)
00292             END DO
00293          END IF
00294 
00295          RNORM = RNORM / CABS1(A(1, 1))
00296          RCOND = 1.0D+0/(RNORM * RINORM)
00297 
00298 *        Calculating the R for normwise rcond.
00299          DO I = 1, N
00300             RINV(I) = 0.0D+0
00301          END DO
00302          DO J = 1, N
00303             DO I = 1, N
00304                RINV(I) = RINV(I) + CABS1(A(I,J))
00305             END DO
00306          END DO
00307 
00308 *        Calculating the Normwise rcond.
00309          RINORM = 0.0D+0
00310          DO I = 1, N
00311             SUMRI = 0.0D+0
00312             DO J = 1, N
00313                SUMRI = SUMRI + CABS1(INVHILB(I,J) * RINV(J))
00314             END DO
00315             RINORM = MAX(RINORM, SUMRI)
00316          END DO
00317 
00318 !        invhilb is the inverse *unscaled* Hilbert matrix, so scale its norm
00319 !        by 1/A(1,1) to make the scaling match A (the scaled Hilbert matrix)
00320          NCOND = CABS1(A(1,1)) / RINORM
00321 
00322          CONDTHRESH = M * EPS
00323          ERRTHRESH = M * EPS
00324 
00325          DO K = 1, NRHS
00326             NORMT = 0.0D+0
00327             NORMDIF = 0.0D+0
00328             CWISE_ERR = 0.0D+0
00329             DO I = 1, N
00330                NORMT = MAX(CABS1(INVHILB(I, K)), NORMT)
00331                NORMDIF = MAX(CABS1(X(I,K) - INVHILB(I,K)), NORMDIF)
00332                IF (INVHILB(I,K) .NE. 0.0D+0) THEN
00333                   CWISE_ERR = MAX(CABS1(X(I,K) - INVHILB(I,K))
00334      $                            /CABS1(INVHILB(I,K)), CWISE_ERR)
00335                ELSE IF (X(I, K) .NE. 0.0D+0) THEN
00336                   CWISE_ERR = DLAMCH('OVERFLOW')
00337                END IF
00338             END DO
00339             IF (NORMT .NE. 0.0D+0) THEN
00340                NWISE_ERR = NORMDIF / NORMT
00341             ELSE IF (NORMDIF .NE. 0.0D+0) THEN
00342                NWISE_ERR = DLAMCH('OVERFLOW')
00343             ELSE
00344                NWISE_ERR = 0.0D+0
00345             ENDIF
00346 
00347             DO I = 1, N
00348                RINV(I) = 0.0D+0
00349             END DO
00350             DO J = 1, N
00351                DO I = 1, N
00352                   RINV(I) = RINV(I) + CABS1(A(I, J) * INVHILB(J, K))
00353                END DO
00354             END DO
00355             RINORM = 0.0D+0
00356             DO I = 1, N
00357                SUMRI = 0.0D+0
00358                DO J = 1, N
00359                   SUMRI = SUMRI
00360      $                 + CABS1(INVHILB(I, J) * RINV(J) / INVHILB(I, K))
00361                END DO
00362                RINORM = MAX(RINORM, SUMRI)
00363             END DO
00364 !        invhilb is the inverse *unscaled* Hilbert matrix, so scale its norm
00365 !        by 1/A(1,1) to make the scaling match A (the scaled Hilbert matrix)
00366             CCOND = CABS1(A(1,1))/RINORM
00367 
00368 !        Forward error bound tests
00369             NWISE_BND = ERRBND_N(K + (BND_I-1)*NRHS)
00370             CWISE_BND = ERRBND_C(K + (BND_I-1)*NRHS)
00371             NWISE_RCOND = ERRBND_N(K + (COND_I-1)*NRHS)
00372             CWISE_RCOND = ERRBND_C(K + (COND_I-1)*NRHS)
00373 !            write (*,*) 'nwise : ', n, k, ncond, nwise_rcond,
00374 !     $           condthresh, ncond.ge.condthresh
00375 !            write (*,*) 'nwise2: ', k, nwise_bnd, nwise_err, errthresh
00376             IF (NCOND .GE. CONDTHRESH) THEN
00377                NGUAR = 'YES'
00378                IF (NWISE_BND .GT. ERRTHRESH) THEN
00379                   TSTRAT(1) = 1/(2.0D+0*EPS)
00380                ELSE
00381                   IF (NWISE_BND .NE. 0.0D+0) THEN
00382                      TSTRAT(1) = NWISE_ERR / NWISE_BND
00383                   ELSE IF (NWISE_ERR .NE. 0.0D+0) THEN
00384                      TSTRAT(1) = 1/(16.0*EPS)
00385                   ELSE
00386                      TSTRAT(1) = 0.0D+0
00387                   END IF
00388                   IF (TSTRAT(1) .GT. 1.0D+0) THEN
00389                      TSTRAT(1) = 1/(4.0D+0*EPS)
00390                   END IF
00391                END IF
00392             ELSE
00393                NGUAR = 'NO'
00394                IF (NWISE_BND .LT. 1.0D+0) THEN
00395                   TSTRAT(1) = 1/(8.0D+0*EPS)
00396                ELSE
00397                   TSTRAT(1) = 1.0D+0
00398                END IF
00399             END IF
00400 !            write (*,*) 'cwise : ', n, k, ccond, cwise_rcond,
00401 !     $           condthresh, ccond.ge.condthresh
00402 !            write (*,*) 'cwise2: ', k, cwise_bnd, cwise_err, errthresh
00403             IF (CCOND .GE. CONDTHRESH) THEN
00404                CGUAR = 'YES'
00405                IF (CWISE_BND .GT. ERRTHRESH) THEN
00406                   TSTRAT(2) = 1/(2.0D+0*EPS)
00407                ELSE
00408                   IF (CWISE_BND .NE. 0.0D+0) THEN
00409                      TSTRAT(2) = CWISE_ERR / CWISE_BND
00410                   ELSE IF (CWISE_ERR .NE. 0.0D+0) THEN
00411                      TSTRAT(2) = 1/(16.0D+0*EPS)
00412                   ELSE
00413                      TSTRAT(2) = 0.0D+0
00414                   END IF
00415                   IF (TSTRAT(2) .GT. 1.0D+0) TSTRAT(2) = 1/(4.0D+0*EPS)
00416                END IF
00417             ELSE
00418                CGUAR = 'NO'
00419                IF (CWISE_BND .LT. 1.0D+0) THEN
00420                   TSTRAT(2) = 1/(8.0D+0*EPS)
00421                ELSE
00422                   TSTRAT(2) = 1.0D+0
00423                END IF
00424             END IF
00425 
00426 !     Backwards error test
00427             TSTRAT(3) = BERR(K)/EPS
00428 
00429 !     Condition number tests
00430             TSTRAT(4) = RCOND / ORCOND
00431             IF (RCOND .GE. CONDTHRESH .AND. TSTRAT(4) .LT. 1.0D+0)
00432      $         TSTRAT(4) = 1.0D+0 / TSTRAT(4)
00433 
00434             TSTRAT(5) = NCOND / NWISE_RCOND
00435             IF (NCOND .GE. CONDTHRESH .AND. TSTRAT(5) .LT. 1.0D+0)
00436      $         TSTRAT(5) = 1.0D+0 / TSTRAT(5)
00437 
00438             TSTRAT(6) = CCOND / NWISE_RCOND
00439             IF (CCOND .GE. CONDTHRESH .AND. TSTRAT(6) .LT. 1.0D+0)
00440      $         TSTRAT(6) = 1.0D+0 / TSTRAT(6)
00441 
00442             DO I = 1, NTESTS
00443                IF (TSTRAT(I) .GT. THRESH) THEN
00444                   IF (.NOT.PRINTED_GUIDE) THEN
00445                      WRITE(*,*)
00446                      WRITE( *, 9996) 1
00447                      WRITE( *, 9995) 2
00448                      WRITE( *, 9994) 3
00449                      WRITE( *, 9993) 4
00450                      WRITE( *, 9992) 5
00451                      WRITE( *, 9991) 6
00452                      WRITE( *, 9990) 7
00453                      WRITE( *, 9989) 8
00454                      WRITE(*,*)
00455                      PRINTED_GUIDE = .TRUE.
00456                   END IF
00457                   WRITE( *, 9999) C2, N, K, NGUAR, CGUAR, I, TSTRAT(I)
00458                   NFAIL = NFAIL + 1
00459                END IF
00460             END DO
00461       END DO
00462 
00463 c$$$         WRITE(*,*)
00464 c$$$         WRITE(*,*) 'Normwise Error Bounds'
00465 c$$$         WRITE(*,*) 'Guaranteed error bound: ',ERRBND(NRHS,nwise_i,bnd_i)
00466 c$$$         WRITE(*,*) 'Reciprocal condition number: ',ERRBND(NRHS,nwise_i,cond_i)
00467 c$$$         WRITE(*,*) 'Raw error estimate: ',ERRBND(NRHS,nwise_i,rawbnd_i)
00468 c$$$         WRITE(*,*)
00469 c$$$         WRITE(*,*) 'Componentwise Error Bounds'
00470 c$$$         WRITE(*,*) 'Guaranteed error bound: ',ERRBND(NRHS,cwise_i,bnd_i)
00471 c$$$         WRITE(*,*) 'Reciprocal condition number: ',ERRBND(NRHS,cwise_i,cond_i)
00472 c$$$         WRITE(*,*) 'Raw error estimate: ',ERRBND(NRHS,cwise_i,rawbnd_i)
00473 c$$$         print *, 'Info: ', info
00474 c$$$         WRITE(*,*)
00475 *         WRITE(*,*) 'TSTRAT: ',TSTRAT
00476 
00477       END DO
00478 
00479       WRITE(*,*)
00480       IF( NFAIL .GT. 0 ) THEN
00481          WRITE(*,9998) C2, NFAIL, NTESTS*N+N_AUX_TESTS
00482       ELSE
00483          WRITE(*,9997) C2
00484       END IF
00485  9999 FORMAT( ' Z', A2, 'SVXX: N =', I2, ', RHS = ', I2,
00486      $     ', NWISE GUAR. = ', A, ', CWISE GUAR. = ', A,
00487      $     ' test(',I1,') =', G12.5 )
00488  9998 FORMAT( ' Z', A2, 'SVXX: ', I6, ' out of ', I6,
00489      $     ' tests failed to pass the threshold' )
00490  9997 FORMAT( ' Z', A2, 'SVXX passed the tests of error bounds' )
00491 *     Test ratios.
00492  9996 FORMAT( 3X, I2, ': Normwise guaranteed forward error', / 5X,
00493      $     'Guaranteed case: if norm ( abs( Xc - Xt )',
00494      $     ' / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ), then',
00495      $     / 5X,
00496      $     'ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS')
00497  9995 FORMAT( 3X, I2, ': Componentwise guaranteed forward error' )
00498  9994 FORMAT( 3X, I2, ': Backwards error' )
00499  9993 FORMAT( 3X, I2, ': Reciprocal condition number' )
00500  9992 FORMAT( 3X, I2, ': Reciprocal normwise condition number' )
00501  9991 FORMAT( 3X, I2, ': Raw normwise error estimate' )
00502  9990 FORMAT( 3X, I2, ': Reciprocal componentwise condition number' )
00503  9989 FORMAT( 3X, I2, ': Raw componentwise error estimate' )
00504 
00505  8000 FORMAT( ' Z', A2, 'SVXX: N =', I2, ', INFO = ', I3,
00506      $     ', ORCOND = ', G12.5, ', real RCOND = ', G12.5 )
00507 
00508       END
 All Files Functions