LAPACK 3.3.0

# zebchvxx.f

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