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