 |
LAPACK 3.3.1
Linear Algebra PACKage
|
|
LAPACK 3.3.1
Linear Algebra PACKage
|
00001 SUBROUTINE SDRVPB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, 00002 $ A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, 00003 $ RWORK, IWORK, NOUT ) 00004 * 00005 * -- LAPACK test routine (version 3.1) -- 00006 * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. 00007 * November 2006 00008 * 00009 * .. Scalar Arguments .. 00010 LOGICAL TSTERR 00011 INTEGER NMAX, NN, NOUT, NRHS 00012 REAL THRESH 00013 * .. 00014 * .. Array Arguments .. 00015 LOGICAL DOTYPE( * ) 00016 INTEGER IWORK( * ), NVAL( * ) 00017 REAL A( * ), AFAC( * ), ASAV( * ), B( * ), 00018 $ BSAV( * ), RWORK( * ), S( * ), WORK( * ), 00019 $ X( * ), XACT( * ) 00020 * .. 00021 * 00022 * Purpose 00023 * ======= 00024 * 00025 * SDRVPB tests the driver routines SPBSV and -SVX. 00026 * 00027 * Arguments 00028 * ========= 00029 * 00030 * DOTYPE (input) LOGICAL array, dimension (NTYPES) 00031 * The matrix types to be used for testing. Matrices of type j 00032 * (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = 00033 * .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 00034 * 00035 * NN (input) INTEGER 00036 * The number of values of N contained in the vector NVAL. 00037 * 00038 * NVAL (input) INTEGER array, dimension (NN) 00039 * The values of the matrix dimension N. 00040 * 00041 * NRHS (input) INTEGER 00042 * The number of right hand side vectors to be generated for 00043 * each linear system. 00044 * 00045 * THRESH (input) REAL 00046 * The threshold value for the test ratios. A result is 00047 * included in the output file if RESULT >= THRESH. To have 00048 * every test ratio printed, use THRESH = 0. 00049 * 00050 * TSTERR (input) LOGICAL 00051 * Flag that indicates whether error exits are to be tested. 00052 * 00053 * NMAX (input) INTEGER 00054 * The maximum value permitted for N, used in dimensioning the 00055 * work arrays. 00056 * 00057 * A (workspace) REAL array, dimension (NMAX*NMAX) 00058 * 00059 * AFAC (workspace) REAL array, dimension (NMAX*NMAX) 00060 * 00061 * ASAV (workspace) REAL array, dimension (NMAX*NMAX) 00062 * 00063 * B (workspace) REAL array, dimension (NMAX*NRHS) 00064 * 00065 * BSAV (workspace) REAL array, dimension (NMAX*NRHS) 00066 * 00067 * X (workspace) REAL array, dimension (NMAX*NRHS) 00068 * 00069 * XACT (workspace) REAL array, dimension (NMAX*NRHS) 00070 * 00071 * S (workspace) REAL array, dimension (NMAX) 00072 * 00073 * WORK (workspace) REAL array, dimension 00074 * (NMAX*max(3,NRHS)) 00075 * 00076 * RWORK (workspace) REAL array, dimension (NMAX+2*NRHS) 00077 * 00078 * IWORK (workspace) INTEGER array, dimension (NMAX) 00079 * 00080 * NOUT (input) INTEGER 00081 * The unit number for output. 00082 * 00083 * ===================================================================== 00084 * 00085 * .. Parameters .. 00086 REAL ONE, ZERO 00087 PARAMETER ( ONE = 1.0E+0, ZERO = 0.0E+0 ) 00088 INTEGER NTYPES, NTESTS 00089 PARAMETER ( NTYPES = 8, NTESTS = 6 ) 00090 INTEGER NBW 00091 PARAMETER ( NBW = 4 ) 00092 * .. 00093 * .. Local Scalars .. 00094 LOGICAL EQUIL, NOFACT, PREFAC, ZEROT 00095 CHARACTER DIST, EQUED, FACT, PACKIT, TYPE, UPLO, XTYPE 00096 CHARACTER*3 PATH 00097 INTEGER I, I1, I2, IEQUED, IFACT, IKD, IMAT, IN, INFO, 00098 $ IOFF, IUPLO, IW, IZERO, K, K1, KD, KL, KOFF, 00099 $ KU, LDA, LDAB, MODE, N, NB, NBMIN, NERRS, 00100 $ NFACT, NFAIL, NIMAT, NKD, NRUN, NT 00101 REAL AINVNM, AMAX, ANORM, CNDNUM, RCOND, RCONDC, 00102 $ ROLDC, SCOND 00103 * .. 00104 * .. Local Arrays .. 00105 CHARACTER EQUEDS( 2 ), FACTS( 3 ) 00106 INTEGER ISEED( 4 ), ISEEDY( 4 ), KDVAL( NBW ) 00107 REAL RESULT( NTESTS ) 00108 * .. 00109 * .. External Functions .. 00110 LOGICAL LSAME 00111 REAL SGET06, SLANGE, SLANSB 00112 EXTERNAL LSAME, SGET06, SLANGE, SLANSB 00113 * .. 00114 * .. External Subroutines .. 00115 EXTERNAL ALADHD, ALAERH, ALASVM, SCOPY, SERRVX, SGET04, 00116 $ SLACPY, SLAQSB, SLARHS, SLASET, SLATB4, SLATMS, 00117 $ SPBEQU, SPBSV, SPBSVX, SPBT01, SPBT02, SPBT05, 00118 $ SPBTRF, SPBTRS, SSWAP, XLAENV 00119 * .. 00120 * .. Intrinsic Functions .. 00121 INTRINSIC MAX, MIN 00122 * .. 00123 * .. Scalars in Common .. 00124 LOGICAL LERR, OK 00125 CHARACTER*32 SRNAMT 00126 INTEGER INFOT, NUNIT 00127 * .. 00128 * .. Common blocks .. 00129 COMMON / INFOC / INFOT, NUNIT, OK, LERR 00130 COMMON / SRNAMC / SRNAMT 00131 * .. 00132 * .. Data statements .. 00133 DATA ISEEDY / 1988, 1989, 1990, 1991 / 00134 DATA FACTS / 'F', 'N', 'E' / 00135 DATA EQUEDS / 'N', 'Y' / 00136 * .. 00137 * .. Executable Statements .. 00138 * 00139 * Initialize constants and the random number seed. 00140 * 00141 PATH( 1: 1 ) = 'Single precision' 00142 PATH( 2: 3 ) = 'PB' 00143 NRUN = 0 00144 NFAIL = 0 00145 NERRS = 0 00146 DO 10 I = 1, 4 00147 ISEED( I ) = ISEEDY( I ) 00148 10 CONTINUE 00149 * 00150 * Test the error exits 00151 * 00152 IF( TSTERR ) 00153 $ CALL SERRVX( PATH, NOUT ) 00154 INFOT = 0 00155 KDVAL( 1 ) = 0 00156 * 00157 * Set the block size and minimum block size for testing. 00158 * 00159 NB = 1 00160 NBMIN = 2 00161 CALL XLAENV( 1, NB ) 00162 CALL XLAENV( 2, NBMIN ) 00163 * 00164 * Do for each value of N in NVAL 00165 * 00166 DO 110 IN = 1, NN 00167 N = NVAL( IN ) 00168 LDA = MAX( N, 1 ) 00169 XTYPE = 'N' 00170 * 00171 * Set limits on the number of loop iterations. 00172 * 00173 NKD = MAX( 1, MIN( N, 4 ) ) 00174 NIMAT = NTYPES 00175 IF( N.EQ.0 ) 00176 $ NIMAT = 1 00177 * 00178 KDVAL( 2 ) = N + ( N+1 ) / 4 00179 KDVAL( 3 ) = ( 3*N-1 ) / 4 00180 KDVAL( 4 ) = ( N+1 ) / 4 00181 * 00182 DO 100 IKD = 1, NKD 00183 * 00184 * Do for KD = 0, (5*N+1)/4, (3N-1)/4, and (N+1)/4. This order 00185 * makes it easier to skip redundant values for small values 00186 * of N. 00187 * 00188 KD = KDVAL( IKD ) 00189 LDAB = KD + 1 00190 * 00191 * Do first for UPLO = 'U', then for UPLO = 'L' 00192 * 00193 DO 90 IUPLO = 1, 2 00194 KOFF = 1 00195 IF( IUPLO.EQ.1 ) THEN 00196 UPLO = 'U' 00197 PACKIT = 'Q' 00198 KOFF = MAX( 1, KD+2-N ) 00199 ELSE 00200 UPLO = 'L' 00201 PACKIT = 'B' 00202 END IF 00203 * 00204 DO 80 IMAT = 1, NIMAT 00205 * 00206 * Do the tests only if DOTYPE( IMAT ) is true. 00207 * 00208 IF( .NOT.DOTYPE( IMAT ) ) 00209 $ GO TO 80 00210 * 00211 * Skip types 2, 3, or 4 if the matrix size is too small. 00212 * 00213 ZEROT = IMAT.GE.2 .AND. IMAT.LE.4 00214 IF( ZEROT .AND. N.LT.IMAT-1 ) 00215 $ GO TO 80 00216 * 00217 IF( .NOT.ZEROT .OR. .NOT.DOTYPE( 1 ) ) THEN 00218 * 00219 * Set up parameters with SLATB4 and generate a test 00220 * matrix with SLATMS. 00221 * 00222 CALL SLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, 00223 $ MODE, CNDNUM, DIST ) 00224 * 00225 SRNAMT = 'SLATMS' 00226 CALL SLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, 00227 $ CNDNUM, ANORM, KD, KD, PACKIT, 00228 $ A( KOFF ), LDAB, WORK, INFO ) 00229 * 00230 * Check error code from SLATMS. 00231 * 00232 IF( INFO.NE.0 ) THEN 00233 CALL ALAERH( PATH, 'SLATMS', INFO, 0, UPLO, N, 00234 $ N, -1, -1, -1, IMAT, NFAIL, NERRS, 00235 $ NOUT ) 00236 GO TO 80 00237 END IF 00238 ELSE IF( IZERO.GT.0 ) THEN 00239 * 00240 * Use the same matrix for types 3 and 4 as for type 00241 * 2 by copying back the zeroed out column, 00242 * 00243 IW = 2*LDA + 1 00244 IF( IUPLO.EQ.1 ) THEN 00245 IOFF = ( IZERO-1 )*LDAB + KD + 1 00246 CALL SCOPY( IZERO-I1, WORK( IW ), 1, 00247 $ A( IOFF-IZERO+I1 ), 1 ) 00248 IW = IW + IZERO - I1 00249 CALL SCOPY( I2-IZERO+1, WORK( IW ), 1, 00250 $ A( IOFF ), MAX( LDAB-1, 1 ) ) 00251 ELSE 00252 IOFF = ( I1-1 )*LDAB + 1 00253 CALL SCOPY( IZERO-I1, WORK( IW ), 1, 00254 $ A( IOFF+IZERO-I1 ), 00255 $ MAX( LDAB-1, 1 ) ) 00256 IOFF = ( IZERO-1 )*LDAB + 1 00257 IW = IW + IZERO - I1 00258 CALL SCOPY( I2-IZERO+1, WORK( IW ), 1, 00259 $ A( IOFF ), 1 ) 00260 END IF 00261 END IF 00262 * 00263 * For types 2-4, zero one row and column of the matrix 00264 * to test that INFO is returned correctly. 00265 * 00266 IZERO = 0 00267 IF( ZEROT ) THEN 00268 IF( IMAT.EQ.2 ) THEN 00269 IZERO = 1 00270 ELSE IF( IMAT.EQ.3 ) THEN 00271 IZERO = N 00272 ELSE 00273 IZERO = N / 2 + 1 00274 END IF 00275 * 00276 * Save the zeroed out row and column in WORK(*,3) 00277 * 00278 IW = 2*LDA 00279 DO 20 I = 1, MIN( 2*KD+1, N ) 00280 WORK( IW+I ) = ZERO 00281 20 CONTINUE 00282 IW = IW + 1 00283 I1 = MAX( IZERO-KD, 1 ) 00284 I2 = MIN( IZERO+KD, N ) 00285 * 00286 IF( IUPLO.EQ.1 ) THEN 00287 IOFF = ( IZERO-1 )*LDAB + KD + 1 00288 CALL SSWAP( IZERO-I1, A( IOFF-IZERO+I1 ), 1, 00289 $ WORK( IW ), 1 ) 00290 IW = IW + IZERO - I1 00291 CALL SSWAP( I2-IZERO+1, A( IOFF ), 00292 $ MAX( LDAB-1, 1 ), WORK( IW ), 1 ) 00293 ELSE 00294 IOFF = ( I1-1 )*LDAB + 1 00295 CALL SSWAP( IZERO-I1, A( IOFF+IZERO-I1 ), 00296 $ MAX( LDAB-1, 1 ), WORK( IW ), 1 ) 00297 IOFF = ( IZERO-1 )*LDAB + 1 00298 IW = IW + IZERO - I1 00299 CALL SSWAP( I2-IZERO+1, A( IOFF ), 1, 00300 $ WORK( IW ), 1 ) 00301 END IF 00302 END IF 00303 * 00304 * Save a copy of the matrix A in ASAV. 00305 * 00306 CALL SLACPY( 'Full', KD+1, N, A, LDAB, ASAV, LDAB ) 00307 * 00308 DO 70 IEQUED = 1, 2 00309 EQUED = EQUEDS( IEQUED ) 00310 IF( IEQUED.EQ.1 ) THEN 00311 NFACT = 3 00312 ELSE 00313 NFACT = 1 00314 END IF 00315 * 00316 DO 60 IFACT = 1, NFACT 00317 FACT = FACTS( IFACT ) 00318 PREFAC = LSAME( FACT, 'F' ) 00319 NOFACT = LSAME( FACT, 'N' ) 00320 EQUIL = LSAME( FACT, 'E' ) 00321 * 00322 IF( ZEROT ) THEN 00323 IF( PREFAC ) 00324 $ GO TO 60 00325 RCONDC = ZERO 00326 * 00327 ELSE IF( .NOT.LSAME( FACT, 'N' ) ) THEN 00328 * 00329 * Compute the condition number for comparison 00330 * with the value returned by SPBSVX (FACT = 00331 * 'N' reuses the condition number from the 00332 * previous iteration with FACT = 'F'). 00333 * 00334 CALL SLACPY( 'Full', KD+1, N, ASAV, LDAB, 00335 $ AFAC, LDAB ) 00336 IF( EQUIL .OR. IEQUED.GT.1 ) THEN 00337 * 00338 * Compute row and column scale factors to 00339 * equilibrate the matrix A. 00340 * 00341 CALL SPBEQU( UPLO, N, KD, AFAC, LDAB, S, 00342 $ SCOND, AMAX, INFO ) 00343 IF( INFO.EQ.0 .AND. N.GT.0 ) THEN 00344 IF( IEQUED.GT.1 ) 00345 $ SCOND = ZERO 00346 * 00347 * Equilibrate the matrix. 00348 * 00349 CALL SLAQSB( UPLO, N, KD, AFAC, LDAB, 00350 $ S, SCOND, AMAX, EQUED ) 00351 END IF 00352 END IF 00353 * 00354 * Save the condition number of the 00355 * non-equilibrated system for use in SGET04. 00356 * 00357 IF( EQUIL ) 00358 $ ROLDC = RCONDC 00359 * 00360 * Compute the 1-norm of A. 00361 * 00362 ANORM = SLANSB( '1', UPLO, N, KD, AFAC, LDAB, 00363 $ RWORK ) 00364 * 00365 * Factor the matrix A. 00366 * 00367 CALL SPBTRF( UPLO, N, KD, AFAC, LDAB, INFO ) 00368 * 00369 * Form the inverse of A. 00370 * 00371 CALL SLASET( 'Full', N, N, ZERO, ONE, A, 00372 $ LDA ) 00373 SRNAMT = 'SPBTRS' 00374 CALL SPBTRS( UPLO, N, KD, N, AFAC, LDAB, A, 00375 $ LDA, INFO ) 00376 * 00377 * Compute the 1-norm condition number of A. 00378 * 00379 AINVNM = SLANGE( '1', N, N, A, LDA, RWORK ) 00380 IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 00381 RCONDC = ONE 00382 ELSE 00383 RCONDC = ( ONE / ANORM ) / AINVNM 00384 END IF 00385 END IF 00386 * 00387 * Restore the matrix A. 00388 * 00389 CALL SLACPY( 'Full', KD+1, N, ASAV, LDAB, A, 00390 $ LDAB ) 00391 * 00392 * Form an exact solution and set the right hand 00393 * side. 00394 * 00395 SRNAMT = 'SLARHS' 00396 CALL SLARHS( PATH, XTYPE, UPLO, ' ', N, N, KD, 00397 $ KD, NRHS, A, LDAB, XACT, LDA, B, 00398 $ LDA, ISEED, INFO ) 00399 XTYPE = 'C' 00400 CALL SLACPY( 'Full', N, NRHS, B, LDA, BSAV, 00401 $ LDA ) 00402 * 00403 IF( NOFACT ) THEN 00404 * 00405 * --- Test SPBSV --- 00406 * 00407 * Compute the L*L' or U'*U factorization of the 00408 * matrix and solve the system. 00409 * 00410 CALL SLACPY( 'Full', KD+1, N, A, LDAB, AFAC, 00411 $ LDAB ) 00412 CALL SLACPY( 'Full', N, NRHS, B, LDA, X, 00413 $ LDA ) 00414 * 00415 SRNAMT = 'SPBSV ' 00416 CALL SPBSV( UPLO, N, KD, NRHS, AFAC, LDAB, X, 00417 $ LDA, INFO ) 00418 * 00419 * Check error code from SPBSV . 00420 * 00421 IF( INFO.NE.IZERO ) THEN 00422 CALL ALAERH( PATH, 'SPBSV ', INFO, IZERO, 00423 $ UPLO, N, N, KD, KD, NRHS, 00424 $ IMAT, NFAIL, NERRS, NOUT ) 00425 GO TO 40 00426 ELSE IF( INFO.NE.0 ) THEN 00427 GO TO 40 00428 END IF 00429 * 00430 * Reconstruct matrix from factors and compute 00431 * residual. 00432 * 00433 CALL SPBT01( UPLO, N, KD, A, LDAB, AFAC, 00434 $ LDAB, RWORK, RESULT( 1 ) ) 00435 * 00436 * Compute residual of the computed solution. 00437 * 00438 CALL SLACPY( 'Full', N, NRHS, B, LDA, WORK, 00439 $ LDA ) 00440 CALL SPBT02( UPLO, N, KD, NRHS, A, LDAB, X, 00441 $ LDA, WORK, LDA, RWORK, 00442 $ RESULT( 2 ) ) 00443 * 00444 * Check solution from generated exact solution. 00445 * 00446 CALL SGET04( N, NRHS, X, LDA, XACT, LDA, 00447 $ RCONDC, RESULT( 3 ) ) 00448 NT = 3 00449 * 00450 * Print information about the tests that did 00451 * not pass the threshold. 00452 * 00453 DO 30 K = 1, NT 00454 IF( RESULT( K ).GE.THRESH ) THEN 00455 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00456 $ CALL ALADHD( NOUT, PATH ) 00457 WRITE( NOUT, FMT = 9999 )'SPBSV ', 00458 $ UPLO, N, KD, IMAT, K, RESULT( K ) 00459 NFAIL = NFAIL + 1 00460 END IF 00461 30 CONTINUE 00462 NRUN = NRUN + NT 00463 40 CONTINUE 00464 END IF 00465 * 00466 * --- Test SPBSVX --- 00467 * 00468 IF( .NOT.PREFAC ) 00469 $ CALL SLASET( 'Full', KD+1, N, ZERO, ZERO, 00470 $ AFAC, LDAB ) 00471 CALL SLASET( 'Full', N, NRHS, ZERO, ZERO, X, 00472 $ LDA ) 00473 IF( IEQUED.GT.1 .AND. N.GT.0 ) THEN 00474 * 00475 * Equilibrate the matrix if FACT='F' and 00476 * EQUED='Y' 00477 * 00478 CALL SLAQSB( UPLO, N, KD, A, LDAB, S, SCOND, 00479 $ AMAX, EQUED ) 00480 END IF 00481 * 00482 * Solve the system and compute the condition 00483 * number and error bounds using SPBSVX. 00484 * 00485 SRNAMT = 'SPBSVX' 00486 CALL SPBSVX( FACT, UPLO, N, KD, NRHS, A, LDAB, 00487 $ AFAC, LDAB, EQUED, S, B, LDA, X, 00488 $ LDA, RCOND, RWORK, RWORK( NRHS+1 ), 00489 $ WORK, IWORK, INFO ) 00490 * 00491 * Check the error code from SPBSVX. 00492 * 00493 IF( INFO.NE.IZERO ) THEN 00494 CALL ALAERH( PATH, 'SPBSVX', INFO, IZERO, 00495 $ FACT // UPLO, N, N, KD, KD, 00496 $ NRHS, IMAT, NFAIL, NERRS, NOUT ) 00497 GO TO 60 00498 END IF 00499 * 00500 IF( INFO.EQ.0 ) THEN 00501 IF( .NOT.PREFAC ) THEN 00502 * 00503 * Reconstruct matrix from factors and 00504 * compute residual. 00505 * 00506 CALL SPBT01( UPLO, N, KD, A, LDAB, AFAC, 00507 $ LDAB, RWORK( 2*NRHS+1 ), 00508 $ RESULT( 1 ) ) 00509 K1 = 1 00510 ELSE 00511 K1 = 2 00512 END IF 00513 * 00514 * Compute residual of the computed solution. 00515 * 00516 CALL SLACPY( 'Full', N, NRHS, BSAV, LDA, 00517 $ WORK, LDA ) 00518 CALL SPBT02( UPLO, N, KD, NRHS, ASAV, LDAB, 00519 $ X, LDA, WORK, LDA, 00520 $ RWORK( 2*NRHS+1 ), RESULT( 2 ) ) 00521 * 00522 * Check solution from generated exact solution. 00523 * 00524 IF( NOFACT .OR. ( PREFAC .AND. LSAME( EQUED, 00525 $ 'N' ) ) ) THEN 00526 CALL SGET04( N, NRHS, X, LDA, XACT, LDA, 00527 $ RCONDC, RESULT( 3 ) ) 00528 ELSE 00529 CALL SGET04( N, NRHS, X, LDA, XACT, LDA, 00530 $ ROLDC, RESULT( 3 ) ) 00531 END IF 00532 * 00533 * Check the error bounds from iterative 00534 * refinement. 00535 * 00536 CALL SPBT05( UPLO, N, KD, NRHS, ASAV, LDAB, 00537 $ B, LDA, X, LDA, XACT, LDA, 00538 $ RWORK, RWORK( NRHS+1 ), 00539 $ RESULT( 4 ) ) 00540 ELSE 00541 K1 = 6 00542 END IF 00543 * 00544 * Compare RCOND from SPBSVX with the computed 00545 * value in RCONDC. 00546 * 00547 RESULT( 6 ) = SGET06( RCOND, RCONDC ) 00548 * 00549 * Print information about the tests that did not 00550 * pass the threshold. 00551 * 00552 DO 50 K = K1, 6 00553 IF( RESULT( K ).GE.THRESH ) THEN 00554 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00555 $ CALL ALADHD( NOUT, PATH ) 00556 IF( PREFAC ) THEN 00557 WRITE( NOUT, FMT = 9997 )'SPBSVX', 00558 $ FACT, UPLO, N, KD, EQUED, IMAT, K, 00559 $ RESULT( K ) 00560 ELSE 00561 WRITE( NOUT, FMT = 9998 )'SPBSVX', 00562 $ FACT, UPLO, N, KD, IMAT, K, 00563 $ RESULT( K ) 00564 END IF 00565 NFAIL = NFAIL + 1 00566 END IF 00567 50 CONTINUE 00568 NRUN = NRUN + 7 - K1 00569 60 CONTINUE 00570 70 CONTINUE 00571 80 CONTINUE 00572 90 CONTINUE 00573 100 CONTINUE 00574 110 CONTINUE 00575 * 00576 * Print a summary of the results. 00577 * 00578 CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS ) 00579 * 00580 9999 FORMAT( 1X, A, ', UPLO=''', A1, ''', N =', I5, ', KD =', I5, 00581 $ ', type ', I1, ', test(', I1, ')=', G12.5 ) 00582 9998 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ', I5, ', ', I5, 00583 $ ', ... ), type ', I1, ', test(', I1, ')=', G12.5 ) 00584 9997 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ', I5, ', ', I5, 00585 $ ', ... ), EQUED=''', A1, ''', type ', I1, ', test(', I1, 00586 $ ')=', G12.5 ) 00587 RETURN 00588 * 00589 * End of SDRVPB 00590 * 00591 END
1.7.3 
