![]() |
LAPACK
3.4.1
LAPACK: Linear Algebra PACKage
|
00001 *> \brief \b DCHKTB 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 DCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, 00012 * NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK, 00013 * NOUT ) 00014 * 00015 * .. Scalar Arguments .. 00016 * LOGICAL TSTERR 00017 * INTEGER NMAX, NN, NNS, NOUT 00018 * DOUBLE PRECISION THRESH 00019 * .. 00020 * .. Array Arguments .. 00021 * LOGICAL DOTYPE( * ) 00022 * INTEGER IWORK( * ), NSVAL( * ), NVAL( * ) 00023 * DOUBLE PRECISION AB( * ), AINV( * ), B( * ), RWORK( * ), 00024 * $ WORK( * ), X( * ), XACT( * ) 00025 * .. 00026 * 00027 * 00028 *> \par Purpose: 00029 * ============= 00030 *> 00031 *> \verbatim 00032 *> 00033 *> DCHKTB tests DTBTRS, -RFS, and -CON, and DLATBS. 00034 *> \endverbatim 00035 * 00036 * Arguments: 00037 * ========== 00038 * 00039 *> \param[in] DOTYPE 00040 *> \verbatim 00041 *> DOTYPE is LOGICAL array, dimension (NTYPES) 00042 *> The matrix types to be used for testing. Matrices of type j 00043 *> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = 00044 *> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 00045 *> \endverbatim 00046 *> 00047 *> \param[in] NN 00048 *> \verbatim 00049 *> NN is INTEGER 00050 *> The number of values of N contained in the vector NVAL. 00051 *> \endverbatim 00052 *> 00053 *> \param[in] NVAL 00054 *> \verbatim 00055 *> NVAL is INTEGER array, dimension (NN) 00056 *> The values of the matrix column dimension N. 00057 *> \endverbatim 00058 *> 00059 *> \param[in] NNS 00060 *> \verbatim 00061 *> NNS is INTEGER 00062 *> The number of values of NRHS contained in the vector NSVAL. 00063 *> \endverbatim 00064 *> 00065 *> \param[in] NSVAL 00066 *> \verbatim 00067 *> NSVAL is INTEGER array, dimension (NNS) 00068 *> The values of the number of right hand sides NRHS. 00069 *> \endverbatim 00070 *> 00071 *> \param[in] THRESH 00072 *> \verbatim 00073 *> THRESH is DOUBLE PRECISION 00074 *> The threshold value for the test ratios. A result is 00075 *> included in the output file if RESULT >= THRESH. To have 00076 *> every test ratio printed, use THRESH = 0. 00077 *> \endverbatim 00078 *> 00079 *> \param[in] TSTERR 00080 *> \verbatim 00081 *> TSTERR is LOGICAL 00082 *> Flag that indicates whether error exits are to be tested. 00083 *> \endverbatim 00084 *> 00085 *> \param[in] NMAX 00086 *> \verbatim 00087 *> NMAX is INTEGER 00088 *> The leading dimension of the work arrays. 00089 *> NMAX >= the maximum value of N in NVAL. 00090 *> \endverbatim 00091 *> 00092 *> \param[out] AB 00093 *> \verbatim 00094 *> AB is DOUBLE PRECISION array, dimension (NMAX*NMAX) 00095 *> \endverbatim 00096 *> 00097 *> \param[out] AINV 00098 *> \verbatim 00099 *> AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 00100 *> \endverbatim 00101 *> 00102 *> \param[out] B 00103 *> \verbatim 00104 *> B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 00105 *> where NSMAX is the largest entry in NSVAL. 00106 *> \endverbatim 00107 *> 00108 *> \param[out] X 00109 *> \verbatim 00110 *> X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 00111 *> \endverbatim 00112 *> 00113 *> \param[out] XACT 00114 *> \verbatim 00115 *> XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 00116 *> \endverbatim 00117 *> 00118 *> \param[out] WORK 00119 *> \verbatim 00120 *> WORK is DOUBLE PRECISION array, dimension 00121 *> (NMAX*max(3,NSMAX)) 00122 *> \endverbatim 00123 *> 00124 *> \param[out] RWORK 00125 *> \verbatim 00126 *> RWORK is DOUBLE PRECISION array, dimension 00127 *> (max(NMAX,2*NSMAX)) 00128 *> \endverbatim 00129 *> 00130 *> \param[out] IWORK 00131 *> \verbatim 00132 *> IWORK is INTEGER array, dimension (NMAX) 00133 *> \endverbatim 00134 *> 00135 *> \param[in] NOUT 00136 *> \verbatim 00137 *> NOUT is INTEGER 00138 *> The unit number for output. 00139 *> \endverbatim 00140 * 00141 * Authors: 00142 * ======== 00143 * 00144 *> \author Univ. of Tennessee 00145 *> \author Univ. of California Berkeley 00146 *> \author Univ. of Colorado Denver 00147 *> \author NAG Ltd. 00148 * 00149 *> \date November 2011 00150 * 00151 *> \ingroup double_lin 00152 * 00153 * ===================================================================== 00154 SUBROUTINE DCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, 00155 $ NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK, 00156 $ NOUT ) 00157 * 00158 * -- LAPACK test routine (version 3.4.0) -- 00159 * -- LAPACK is a software package provided by Univ. of Tennessee, -- 00160 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 00161 * November 2011 00162 * 00163 * .. Scalar Arguments .. 00164 LOGICAL TSTERR 00165 INTEGER NMAX, NN, NNS, NOUT 00166 DOUBLE PRECISION THRESH 00167 * .. 00168 * .. Array Arguments .. 00169 LOGICAL DOTYPE( * ) 00170 INTEGER IWORK( * ), NSVAL( * ), NVAL( * ) 00171 DOUBLE PRECISION AB( * ), AINV( * ), B( * ), RWORK( * ), 00172 $ WORK( * ), X( * ), XACT( * ) 00173 * .. 00174 * 00175 * ===================================================================== 00176 * 00177 * .. Parameters .. 00178 INTEGER NTYPE1, NTYPES 00179 PARAMETER ( NTYPE1 = 9, NTYPES = 17 ) 00180 INTEGER NTESTS 00181 PARAMETER ( NTESTS = 8 ) 00182 INTEGER NTRAN 00183 PARAMETER ( NTRAN = 3 ) 00184 DOUBLE PRECISION ONE, ZERO 00185 PARAMETER ( ONE = 1.0D+0, ZERO = 0.0D+0 ) 00186 * .. 00187 * .. Local Scalars .. 00188 CHARACTER DIAG, NORM, TRANS, UPLO, XTYPE 00189 CHARACTER*3 PATH 00190 INTEGER I, IDIAG, IK, IMAT, IN, INFO, IRHS, ITRAN, 00191 $ IUPLO, J, K, KD, LDA, LDAB, N, NERRS, NFAIL, 00192 $ NIMAT, NIMAT2, NK, NRHS, NRUN 00193 DOUBLE PRECISION AINVNM, ANORM, RCOND, RCONDC, RCONDI, RCONDO, 00194 $ SCALE 00195 * .. 00196 * .. Local Arrays .. 00197 CHARACTER TRANSS( NTRAN ), UPLOS( 2 ) 00198 INTEGER ISEED( 4 ), ISEEDY( 4 ) 00199 DOUBLE PRECISION RESULT( NTESTS ) 00200 * .. 00201 * .. External Functions .. 00202 LOGICAL LSAME 00203 DOUBLE PRECISION DLANTB, DLANTR 00204 EXTERNAL LSAME, DLANTB, DLANTR 00205 * .. 00206 * .. External Subroutines .. 00207 EXTERNAL ALAERH, ALAHD, ALASUM, DCOPY, DERRTR, DGET04, 00208 $ DLACPY, DLARHS, DLASET, DLATBS, DLATTB, DTBCON, 00209 $ DTBRFS, DTBSV, DTBT02, DTBT03, DTBT05, DTBT06, 00210 $ DTBTRS 00211 * .. 00212 * .. Scalars in Common .. 00213 LOGICAL LERR, OK 00214 CHARACTER*32 SRNAMT 00215 INTEGER INFOT, IOUNIT 00216 * .. 00217 * .. Common blocks .. 00218 COMMON / INFOC / INFOT, IOUNIT, OK, LERR 00219 COMMON / SRNAMC / SRNAMT 00220 * .. 00221 * .. Intrinsic Functions .. 00222 INTRINSIC MAX, MIN 00223 * .. 00224 * .. Data statements .. 00225 DATA ISEEDY / 1988, 1989, 1990, 1991 / 00226 DATA UPLOS / 'U', 'L' / , TRANSS / 'N', 'T', 'C' / 00227 * .. 00228 * .. Executable Statements .. 00229 * 00230 * Initialize constants and the random number seed. 00231 * 00232 PATH( 1: 1 ) = 'Double precision' 00233 PATH( 2: 3 ) = 'TB' 00234 NRUN = 0 00235 NFAIL = 0 00236 NERRS = 0 00237 DO 10 I = 1, 4 00238 ISEED( I ) = ISEEDY( I ) 00239 10 CONTINUE 00240 * 00241 * Test the error exits 00242 * 00243 IF( TSTERR ) 00244 $ CALL DERRTR( PATH, NOUT ) 00245 INFOT = 0 00246 * 00247 DO 140 IN = 1, NN 00248 * 00249 * Do for each value of N in NVAL 00250 * 00251 N = NVAL( IN ) 00252 LDA = MAX( 1, N ) 00253 XTYPE = 'N' 00254 NIMAT = NTYPE1 00255 NIMAT2 = NTYPES 00256 IF( N.LE.0 ) THEN 00257 NIMAT = 1 00258 NIMAT2 = NTYPE1 + 1 00259 END IF 00260 * 00261 NK = MIN( N+1, 4 ) 00262 DO 130 IK = 1, NK 00263 * 00264 * Do for KD = 0, N, (3N-1)/4, and (N+1)/4. This order makes 00265 * it easier to skip redundant values for small values of N. 00266 * 00267 IF( IK.EQ.1 ) THEN 00268 KD = 0 00269 ELSE IF( IK.EQ.2 ) THEN 00270 KD = MAX( N, 0 ) 00271 ELSE IF( IK.EQ.3 ) THEN 00272 KD = ( 3*N-1 ) / 4 00273 ELSE IF( IK.EQ.4 ) THEN 00274 KD = ( N+1 ) / 4 00275 END IF 00276 LDAB = KD + 1 00277 * 00278 DO 90 IMAT = 1, NIMAT 00279 * 00280 * Do the tests only if DOTYPE( IMAT ) is true. 00281 * 00282 IF( .NOT.DOTYPE( IMAT ) ) 00283 $ GO TO 90 00284 * 00285 DO 80 IUPLO = 1, 2 00286 * 00287 * Do first for UPLO = 'U', then for UPLO = 'L' 00288 * 00289 UPLO = UPLOS( IUPLO ) 00290 * 00291 * Call DLATTB to generate a triangular test matrix. 00292 * 00293 SRNAMT = 'DLATTB' 00294 CALL DLATTB( IMAT, UPLO, 'No transpose', DIAG, ISEED, 00295 $ N, KD, AB, LDAB, X, WORK, INFO ) 00296 * 00297 * Set IDIAG = 1 for non-unit matrices, 2 for unit. 00298 * 00299 IF( LSAME( DIAG, 'N' ) ) THEN 00300 IDIAG = 1 00301 ELSE 00302 IDIAG = 2 00303 END IF 00304 * 00305 * Form the inverse of A so we can get a good estimate 00306 * of RCONDC = 1/(norm(A) * norm(inv(A))). 00307 * 00308 CALL DLASET( 'Full', N, N, ZERO, ONE, AINV, LDA ) 00309 IF( LSAME( UPLO, 'U' ) ) THEN 00310 DO 20 J = 1, N 00311 CALL DTBSV( UPLO, 'No transpose', DIAG, J, KD, 00312 $ AB, LDAB, AINV( ( J-1 )*LDA+1 ), 1 ) 00313 20 CONTINUE 00314 ELSE 00315 DO 30 J = 1, N 00316 CALL DTBSV( UPLO, 'No transpose', DIAG, N-J+1, 00317 $ KD, AB( ( J-1 )*LDAB+1 ), LDAB, 00318 $ AINV( ( J-1 )*LDA+J ), 1 ) 00319 30 CONTINUE 00320 END IF 00321 * 00322 * Compute the 1-norm condition number of A. 00323 * 00324 ANORM = DLANTB( '1', UPLO, DIAG, N, KD, AB, LDAB, 00325 $ RWORK ) 00326 AINVNM = DLANTR( '1', UPLO, DIAG, N, N, AINV, LDA, 00327 $ RWORK ) 00328 IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 00329 RCONDO = ONE 00330 ELSE 00331 RCONDO = ( ONE / ANORM ) / AINVNM 00332 END IF 00333 * 00334 * Compute the infinity-norm condition number of A. 00335 * 00336 ANORM = DLANTB( 'I', UPLO, DIAG, N, KD, AB, LDAB, 00337 $ RWORK ) 00338 AINVNM = DLANTR( 'I', UPLO, DIAG, N, N, AINV, LDA, 00339 $ RWORK ) 00340 IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 00341 RCONDI = ONE 00342 ELSE 00343 RCONDI = ( ONE / ANORM ) / AINVNM 00344 END IF 00345 * 00346 DO 60 IRHS = 1, NNS 00347 NRHS = NSVAL( IRHS ) 00348 XTYPE = 'N' 00349 * 00350 DO 50 ITRAN = 1, NTRAN 00351 * 00352 * Do for op(A) = A, A**T, or A**H. 00353 * 00354 TRANS = TRANSS( ITRAN ) 00355 IF( ITRAN.EQ.1 ) THEN 00356 NORM = 'O' 00357 RCONDC = RCONDO 00358 ELSE 00359 NORM = 'I' 00360 RCONDC = RCONDI 00361 END IF 00362 * 00363 *+ TEST 1 00364 * Solve and compute residual for op(A)*x = b. 00365 * 00366 SRNAMT = 'DLARHS' 00367 CALL DLARHS( PATH, XTYPE, UPLO, TRANS, N, N, KD, 00368 $ IDIAG, NRHS, AB, LDAB, XACT, LDA, 00369 $ B, LDA, ISEED, INFO ) 00370 XTYPE = 'C' 00371 CALL DLACPY( 'Full', N, NRHS, B, LDA, X, LDA ) 00372 * 00373 SRNAMT = 'DTBTRS' 00374 CALL DTBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, 00375 $ LDAB, X, LDA, INFO ) 00376 * 00377 * Check error code from DTBTRS. 00378 * 00379 IF( INFO.NE.0 ) 00380 $ CALL ALAERH( PATH, 'DTBTRS', INFO, 0, 00381 $ UPLO // TRANS // DIAG, N, N, KD, 00382 $ KD, NRHS, IMAT, NFAIL, NERRS, 00383 $ NOUT ) 00384 * 00385 CALL DTBT02( UPLO, TRANS, DIAG, N, KD, NRHS, AB, 00386 $ LDAB, X, LDA, B, LDA, WORK, 00387 $ RESULT( 1 ) ) 00388 * 00389 *+ TEST 2 00390 * Check solution from generated exact solution. 00391 * 00392 CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC, 00393 $ RESULT( 2 ) ) 00394 * 00395 *+ TESTS 3, 4, and 5 00396 * Use iterative refinement to improve the solution 00397 * and compute error bounds. 00398 * 00399 SRNAMT = 'DTBRFS' 00400 CALL DTBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, 00401 $ LDAB, B, LDA, X, LDA, RWORK, 00402 $ RWORK( NRHS+1 ), WORK, IWORK, 00403 $ INFO ) 00404 * 00405 * Check error code from DTBRFS. 00406 * 00407 IF( INFO.NE.0 ) 00408 $ CALL ALAERH( PATH, 'DTBRFS', INFO, 0, 00409 $ UPLO // TRANS // DIAG, N, N, KD, 00410 $ KD, NRHS, IMAT, NFAIL, NERRS, 00411 $ NOUT ) 00412 * 00413 CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC, 00414 $ RESULT( 3 ) ) 00415 CALL DTBT05( UPLO, TRANS, DIAG, N, KD, NRHS, AB, 00416 $ LDAB, B, LDA, X, LDA, XACT, LDA, 00417 $ RWORK, RWORK( NRHS+1 ), 00418 $ RESULT( 4 ) ) 00419 * 00420 * Print information about the tests that did not 00421 * pass the threshold. 00422 * 00423 DO 40 K = 1, 5 00424 IF( RESULT( K ).GE.THRESH ) THEN 00425 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00426 $ CALL ALAHD( NOUT, PATH ) 00427 WRITE( NOUT, FMT = 9999 )UPLO, TRANS, 00428 $ DIAG, N, KD, NRHS, IMAT, K, RESULT( K ) 00429 NFAIL = NFAIL + 1 00430 END IF 00431 40 CONTINUE 00432 NRUN = NRUN + 5 00433 50 CONTINUE 00434 60 CONTINUE 00435 * 00436 *+ TEST 6 00437 * Get an estimate of RCOND = 1/CNDNUM. 00438 * 00439 DO 70 ITRAN = 1, 2 00440 IF( ITRAN.EQ.1 ) THEN 00441 NORM = 'O' 00442 RCONDC = RCONDO 00443 ELSE 00444 NORM = 'I' 00445 RCONDC = RCONDI 00446 END IF 00447 SRNAMT = 'DTBCON' 00448 CALL DTBCON( NORM, UPLO, DIAG, N, KD, AB, LDAB, 00449 $ RCOND, WORK, IWORK, INFO ) 00450 * 00451 * Check error code from DTBCON. 00452 * 00453 IF( INFO.NE.0 ) 00454 $ CALL ALAERH( PATH, 'DTBCON', INFO, 0, 00455 $ NORM // UPLO // DIAG, N, N, KD, KD, 00456 $ -1, IMAT, NFAIL, NERRS, NOUT ) 00457 * 00458 CALL DTBT06( RCOND, RCONDC, UPLO, DIAG, N, KD, AB, 00459 $ LDAB, RWORK, RESULT( 6 ) ) 00460 * 00461 * Print information about the tests that did not pass 00462 * the threshold. 00463 * 00464 IF( RESULT( 6 ).GE.THRESH ) THEN 00465 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00466 $ CALL ALAHD( NOUT, PATH ) 00467 WRITE( NOUT, FMT = 9998 ) 'DTBCON', NORM, UPLO, 00468 $ DIAG, N, KD, IMAT, 6, RESULT( 6 ) 00469 NFAIL = NFAIL + 1 00470 END IF 00471 NRUN = NRUN + 1 00472 70 CONTINUE 00473 80 CONTINUE 00474 90 CONTINUE 00475 * 00476 * Use pathological test matrices to test DLATBS. 00477 * 00478 DO 120 IMAT = NTYPE1 + 1, NIMAT2 00479 * 00480 * Do the tests only if DOTYPE( IMAT ) is true. 00481 * 00482 IF( .NOT.DOTYPE( IMAT ) ) 00483 $ GO TO 120 00484 * 00485 DO 110 IUPLO = 1, 2 00486 * 00487 * Do first for UPLO = 'U', then for UPLO = 'L' 00488 * 00489 UPLO = UPLOS( IUPLO ) 00490 DO 100 ITRAN = 1, NTRAN 00491 * 00492 * Do for op(A) = A, A**T, and A**H. 00493 * 00494 TRANS = TRANSS( ITRAN ) 00495 * 00496 * Call DLATTB to generate a triangular test matrix. 00497 * 00498 SRNAMT = 'DLATTB' 00499 CALL DLATTB( IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, 00500 $ AB, LDAB, X, WORK, INFO ) 00501 * 00502 *+ TEST 7 00503 * Solve the system op(A)*x = b 00504 * 00505 SRNAMT = 'DLATBS' 00506 CALL DCOPY( N, X, 1, B, 1 ) 00507 CALL DLATBS( UPLO, TRANS, DIAG, 'N', N, KD, AB, 00508 $ LDAB, B, SCALE, RWORK, INFO ) 00509 * 00510 * Check error code from DLATBS. 00511 * 00512 IF( INFO.NE.0 ) 00513 $ CALL ALAERH( PATH, 'DLATBS', INFO, 0, 00514 $ UPLO // TRANS // DIAG // 'N', N, N, 00515 $ KD, KD, -1, IMAT, NFAIL, NERRS, 00516 $ NOUT ) 00517 * 00518 CALL DTBT03( UPLO, TRANS, DIAG, N, KD, 1, AB, LDAB, 00519 $ SCALE, RWORK, ONE, B, LDA, X, LDA, 00520 $ WORK, RESULT( 7 ) ) 00521 * 00522 *+ TEST 8 00523 * Solve op(A)*x = b again with NORMIN = 'Y'. 00524 * 00525 CALL DCOPY( N, X, 1, B, 1 ) 00526 CALL DLATBS( UPLO, TRANS, DIAG, 'Y', N, KD, AB, 00527 $ LDAB, B, SCALE, RWORK, INFO ) 00528 * 00529 * Check error code from DLATBS. 00530 * 00531 IF( INFO.NE.0 ) 00532 $ CALL ALAERH( PATH, 'DLATBS', INFO, 0, 00533 $ UPLO // TRANS // DIAG // 'Y', N, N, 00534 $ KD, KD, -1, IMAT, NFAIL, NERRS, 00535 $ NOUT ) 00536 * 00537 CALL DTBT03( UPLO, TRANS, DIAG, N, KD, 1, AB, LDAB, 00538 $ SCALE, RWORK, ONE, B, LDA, X, LDA, 00539 $ WORK, RESULT( 8 ) ) 00540 * 00541 * Print information about the tests that did not pass 00542 * the threshold. 00543 * 00544 IF( RESULT( 7 ).GE.THRESH ) THEN 00545 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00546 $ CALL ALAHD( NOUT, PATH ) 00547 WRITE( NOUT, FMT = 9997 )'DLATBS', UPLO, TRANS, 00548 $ DIAG, 'N', N, KD, IMAT, 7, RESULT( 7 ) 00549 NFAIL = NFAIL + 1 00550 END IF 00551 IF( RESULT( 8 ).GE.THRESH ) THEN 00552 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00553 $ CALL ALAHD( NOUT, PATH ) 00554 WRITE( NOUT, FMT = 9997 )'DLATBS', UPLO, TRANS, 00555 $ DIAG, 'Y', N, KD, IMAT, 8, RESULT( 8 ) 00556 NFAIL = NFAIL + 1 00557 END IF 00558 NRUN = NRUN + 2 00559 100 CONTINUE 00560 110 CONTINUE 00561 120 CONTINUE 00562 130 CONTINUE 00563 140 CONTINUE 00564 * 00565 * Print a summary of the results. 00566 * 00567 CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS ) 00568 * 00569 9999 FORMAT( ' UPLO=''', A1, ''', TRANS=''', A1, '' 00570 ', $ DIAG=''', A1, ''', N=', I5, ', KD=', I5, ', NRHS=', I5, 00571 $ ', type ', I2, ', test(', I2, ')=', G12.5 ) 00572 9998 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ''', A1, ''',', 00573 $ I5, ',', I5, ', ... ), type ', I2, ', test(', I2, ')=', 00574 $ G12.5 ) 00575 9997 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ''', A1, ''', ''', 00576 $ A1, ''',', I5, ',', I5, ', ... ), type ', I2, ', test(', 00577 $ I1, ')=', G12.5 ) 00578 RETURN 00579 * 00580 * End of DCHKTB 00581 * 00582 END