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