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