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