![]() |
LAPACK
3.4.1
LAPACK: Linear Algebra PACKage
|
00001 *> \brief \b CEBCHVXX 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 CEBCHVXX( THRESH, PATH ) 00012 * 00013 * .. Scalar Arguments .. 00014 * REAL THRESH 00015 * CHARACTER*3 PATH 00016 * .. 00017 * 00018 * Purpose 00019 * ====== 00020 * 00021 *> \details \b Purpose: 00022 *> \verbatim 00023 *> 00024 *> CEBCHVXX will run CGESVXX on a series of Hilbert matrices and then 00025 *> compare the error bounds returned by CGESVXX 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 complex_lin 00095 * 00096 * ===================================================================== 00097 SUBROUTINE CEBCHVXX( THRESH, PATH ) 00098 IMPLICIT NONE 00099 * .. Scalar Arguments .. 00100 REAL THRESH 00101 CHARACTER*3 PATH 00102 00103 INTEGER NMAX, NPARAMS, NERRBND, NTESTS, KL, KU 00104 PARAMETER (NMAX = 6, 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 REAL 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 ZDUM 00121 00122 * .. Local Arrays .. 00123 REAL 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 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 REAL SLAMCH 00137 00138 * .. External Subroutines .. 00139 EXTERNAL CLAHILB, CGESVXX, CSYSVXX, CPOSVXX, 00140 $ CGBSVXX, CLACPY, LSAMEN 00141 LOGICAL LSAMEN 00142 00143 * .. Intrinsic Functions .. 00144 INTRINSIC SQRT, MAX, ABS, REAL, AIMAG 00145 00146 * .. Statement Functions .. 00147 REAL CABS1 00148 * .. 00149 * .. Statement Function Definitions .. 00150 CABS1( ZDUM ) = ABS( REAL( ZDUM ) ) + ABS( AIMAG( 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 = SLAMCH('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(REAL(N)), 10.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 CLAHILB(N, N, A, LDA, INVHILB, LDA, B, 00188 $ LDA, WORK, INFO, PATH) 00189 00190 * Copy A into ACOPY. 00191 CALL CLACPY('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.0E+0,0.0E+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.0E+0,0.0E+0) 00209 END DO 00210 END DO 00211 CALL CLACPY('ALL', KL+KU+1, N, AB, LDAB, ABCOPY, LDAB) 00212 00213 * Call C**SVXX with default PARAMS and N_ERR_BND = 3. 00214 IF ( LSAMEN( 2, C2, 'SY' ) ) THEN 00215 CALL CSYSVXX(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 CPOSVXX(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 CHESVXX(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 CGBSVXX(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 CGESVXX(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 C**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.0/(RNORM * RINORM) 00297 00298 * Calculating the R for normwise rcond. 00299 DO I = 1, N 00300 RINV(I) = 0.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.0 00310 DO I = 1, N 00311 SUMRI = 0.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.0 00327 NORMDIF = 0.0 00328 CWISE_ERR = 0.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.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.0) THEN 00336 CWISE_ERR = SLAMCH('OVERFLOW') 00337 END IF 00338 END DO 00339 IF (NORMT .NE. 0.0) THEN 00340 NWISE_ERR = NORMDIF / NORMT 00341 ELSE IF (NORMDIF .NE. 0.0) THEN 00342 NWISE_ERR = SLAMCH('OVERFLOW') 00343 ELSE 00344 NWISE_ERR = 0.0 00345 ENDIF 00346 00347 DO I = 1, N 00348 RINV(I) = 0.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.0 00356 DO I = 1, N 00357 SUMRI = 0.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.0*EPS) 00380 ELSE 00381 IF (NWISE_BND .NE. 0.0) THEN 00382 TSTRAT(1) = NWISE_ERR / NWISE_BND 00383 ELSE IF (NWISE_ERR .NE. 0.0) THEN 00384 TSTRAT(1) = 1/(16.0*EPS) 00385 ELSE 00386 TSTRAT(1) = 0.0 00387 END IF 00388 IF (TSTRAT(1) .GT. 1.0) THEN 00389 TSTRAT(1) = 1/(4.0*EPS) 00390 END IF 00391 END IF 00392 ELSE 00393 NGUAR = 'NO' 00394 IF (NWISE_BND .LT. 1.0) THEN 00395 TSTRAT(1) = 1/(8.0*EPS) 00396 ELSE 00397 TSTRAT(1) = 1.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.0*EPS) 00407 ELSE 00408 IF (CWISE_BND .NE. 0.0) THEN 00409 TSTRAT(2) = CWISE_ERR / CWISE_BND 00410 ELSE IF (CWISE_ERR .NE. 0.0) THEN 00411 TSTRAT(2) = 1/(16.0*EPS) 00412 ELSE 00413 TSTRAT(2) = 0.0 00414 END IF 00415 IF (TSTRAT(2) .GT. 1.0) TSTRAT(2) = 1/(4.0*EPS) 00416 END IF 00417 ELSE 00418 CGUAR = 'NO' 00419 IF (CWISE_BND .LT. 1.0) THEN 00420 TSTRAT(2) = 1/(8.0*EPS) 00421 ELSE 00422 TSTRAT(2) = 1.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.0) 00432 $ TSTRAT(4) = 1.0 / TSTRAT(4) 00433 00434 TSTRAT(5) = NCOND / NWISE_RCOND 00435 IF (NCOND .GE. CONDTHRESH .AND. TSTRAT(5) .LT. 1.0) 00436 $ TSTRAT(5) = 1.0 / TSTRAT(5) 00437 00438 TSTRAT(6) = CCOND / NWISE_RCOND 00439 IF (CCOND .GE. CONDTHRESH .AND. TSTRAT(6) .LT. 1.0) 00440 $ TSTRAT(6) = 1.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( ' C', A2, 'SVXX: N =', I2, ', RHS = ', I2, 00486 $ ', NWISE GUAR. = ', A, ', CWISE GUAR. = ', A, 00487 $ ' test(',I1,') =', G12.5 ) 00488 9998 FORMAT( ' C', A2, 'SVXX: ', I6, ' out of ', I6, 00489 $ ' tests failed to pass the threshold' ) 00490 9997 FORMAT( ' C', 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( ' C', A2, 'SVXX: N =', I2, ', INFO = ', I3, 00506 $ ', ORCOND = ', G12.5, ', real RCOND = ', G12.5 ) 00507 00508 END