1*> \brief \b CCHKHE 2* 3* =========== DOCUMENTATION =========== 4* 5* Online html documentation available at 6* http://www.netlib.org/lapack/explore-html/ 7* 8* Definition: 9* =========== 10* 11* SUBROUTINE CCHKHE( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, 12* THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, 13* XACT, WORK, RWORK, IWORK, NOUT ) 14* 15* .. Scalar Arguments .. 16* LOGICAL TSTERR 17* INTEGER NMAX, NN, NNB, NNS, NOUT 18* REAL THRESH 19* .. 20* .. Array Arguments .. 21* LOGICAL DOTYPE( * ) 22* INTEGER IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * ) 23* REAL RWORK( * ) 24* COMPLEX A( * ), AFAC( * ), AINV( * ), B( * ), 25* $ WORK( * ), X( * ), XACT( * ) 26* .. 27* 28* 29*> \par Purpose: 30* ============= 31*> 32*> \verbatim 33*> 34*> CCHKHE tests CHETRF, -TRI2, -TRS, -TRS2, -RFS, and -CON. 35*> \endverbatim 36* 37* Arguments: 38* ========== 39* 40*> \param[in] DOTYPE 41*> \verbatim 42*> DOTYPE is LOGICAL array, dimension (NTYPES) 43*> The matrix types to be used for testing. Matrices of type j 44*> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = 45*> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 46*> \endverbatim 47*> 48*> \param[in] NN 49*> \verbatim 50*> NN is INTEGER 51*> The number of values of N contained in the vector NVAL. 52*> \endverbatim 53*> 54*> \param[in] NVAL 55*> \verbatim 56*> NVAL is INTEGER array, dimension (NN) 57*> The values of the matrix dimension N. 58*> \endverbatim 59*> 60*> \param[in] NNB 61*> \verbatim 62*> NNB is INTEGER 63*> The number of values of NB contained in the vector NBVAL. 64*> \endverbatim 65*> 66*> \param[in] NBVAL 67*> \verbatim 68*> NBVAL is INTEGER array, dimension (NNB) 69*> The values of the blocksize NB. 70*> \endverbatim 71*> 72*> \param[in] NNS 73*> \verbatim 74*> NNS is INTEGER 75*> The number of values of NRHS contained in the vector NSVAL. 76*> \endverbatim 77*> 78*> \param[in] NSVAL 79*> \verbatim 80*> NSVAL is INTEGER array, dimension (NNS) 81*> The values of the number of right hand sides NRHS. 82*> \endverbatim 83*> 84*> \param[in] THRESH 85*> \verbatim 86*> THRESH is REAL 87*> The threshold value for the test ratios. A result is 88*> included in the output file if RESULT >= THRESH. To have 89*> every test ratio printed, use THRESH = 0. 90*> \endverbatim 91*> 92*> \param[in] TSTERR 93*> \verbatim 94*> TSTERR is LOGICAL 95*> Flag that indicates whether error exits are to be tested. 96*> \endverbatim 97*> 98*> \param[in] NMAX 99*> \verbatim 100*> NMAX is INTEGER 101*> The maximum value permitted for N, used in dimensioning the 102*> work arrays. 103*> \endverbatim 104*> 105*> \param[out] A 106*> \verbatim 107*> A is COMPLEX array, dimension (NMAX*NMAX) 108*> \endverbatim 109*> 110*> \param[out] AFAC 111*> \verbatim 112*> AFAC is COMPLEX array, dimension (NMAX*NMAX) 113*> \endverbatim 114*> 115*> \param[out] AINV 116*> \verbatim 117*> AINV is COMPLEX array, dimension (NMAX*NMAX) 118*> \endverbatim 119*> 120*> \param[out] B 121*> \verbatim 122*> B is COMPLEX array, dimension (NMAX*NSMAX) 123*> where NSMAX is the largest entry in NSVAL. 124*> \endverbatim 125*> 126*> \param[out] X 127*> \verbatim 128*> X is COMPLEX array, dimension (NMAX*NSMAX) 129*> \endverbatim 130*> 131*> \param[out] XACT 132*> \verbatim 133*> XACT is COMPLEX array, dimension (NMAX*NSMAX) 134*> \endverbatim 135*> 136*> \param[out] WORK 137*> \verbatim 138*> WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 139*> \endverbatim 140*> 141*> \param[out] RWORK 142*> \verbatim 143*> RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 144*> \endverbatim 145*> 146*> \param[out] IWORK 147*> \verbatim 148*> IWORK is INTEGER array, dimension (NMAX) 149*> \endverbatim 150*> 151*> \param[in] NOUT 152*> \verbatim 153*> NOUT is INTEGER 154*> The unit number for output. 155*> \endverbatim 156* 157* Authors: 158* ======== 159* 160*> \author Univ. of Tennessee 161*> \author Univ. of California Berkeley 162*> \author Univ. of Colorado Denver 163*> \author NAG Ltd. 164* 165*> \ingroup complex_lin 166* 167* ===================================================================== 168 SUBROUTINE CCHKHE( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, 169 $ THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, 170 $ XACT, WORK, RWORK, IWORK, NOUT ) 171* 172* -- LAPACK test routine -- 173* -- LAPACK is a software package provided by Univ. of Tennessee, -- 174* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 175* 176* .. Scalar Arguments .. 177 LOGICAL TSTERR 178 INTEGER NMAX, NN, NNB, NNS, NOUT 179 REAL THRESH 180* .. 181* .. Array Arguments .. 182 LOGICAL DOTYPE( * ) 183 INTEGER IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * ) 184 REAL RWORK( * ) 185 COMPLEX A( * ), AFAC( * ), AINV( * ), B( * ), 186 $ WORK( * ), X( * ), XACT( * ) 187* .. 188* 189* ===================================================================== 190* 191* .. Parameters .. 192 REAL ZERO 193 PARAMETER ( ZERO = 0.0E+0 ) 194 COMPLEX CZERO 195 PARAMETER ( CZERO = ( 0.0E+0, 0.0E+0 ) ) 196 INTEGER NTYPES 197 PARAMETER ( NTYPES = 10 ) 198 INTEGER NTESTS 199 PARAMETER ( NTESTS = 9 ) 200* .. 201* .. Local Scalars .. 202 LOGICAL TRFCON, ZEROT 203 CHARACTER DIST, TYPE, UPLO, XTYPE 204 CHARACTER*3 PATH 205 INTEGER I, I1, I2, IMAT, IN, INB, INFO, IOFF, IRHS, 206 $ IUPLO, IZERO, J, K, KL, KU, LDA, LWORK, MODE, 207 $ N, NB, NERRS, NFAIL, NIMAT, NRHS, NRUN, NT 208 REAL ANORM, CNDNUM, RCOND, RCONDC 209* .. 210* .. Local Arrays .. 211 CHARACTER UPLOS( 2 ) 212 INTEGER ISEED( 4 ), ISEEDY( 4 ) 213 REAL RESULT( NTESTS ) 214* .. 215* .. External Functions .. 216 REAL CLANHE, SGET06 217 EXTERNAL CLANHE, SGET06 218* .. 219* .. External Subroutines .. 220 EXTERNAL ALAERH, ALAHD, ALASUM, CERRHE, CGET04, CHECON, 221 $ CHERFS, CHET01, CHETRF, CHETRI2, CHETRS, 222 $ CLACPY, CLAIPD, CLARHS, CLATB4, CLATMS, CPOT02, 223 $ CPOT03, CPOT05, XLAENV 224* .. 225* .. Intrinsic Functions .. 226 INTRINSIC MAX, MIN 227* .. 228* .. Scalars in Common .. 229 LOGICAL LERR, OK 230 CHARACTER*32 SRNAMT 231 INTEGER INFOT, NUNIT 232* .. 233* .. Common blocks .. 234 COMMON / INFOC / INFOT, NUNIT, OK, LERR 235 COMMON / SRNAMC / SRNAMT 236* .. 237* .. Data statements .. 238 DATA ISEEDY / 1988, 1989, 1990, 1991 / 239 DATA UPLOS / 'U', 'L' / 240* .. 241* .. Executable Statements .. 242* 243* Initialize constants and the random number seed. 244* 245 PATH( 1: 1 ) = 'Complex precision' 246 PATH( 2: 3 ) = 'HE' 247 NRUN = 0 248 NFAIL = 0 249 NERRS = 0 250 DO 10 I = 1, 4 251 ISEED( I ) = ISEEDY( I ) 252 10 CONTINUE 253* 254* Test the error exits 255* 256 IF( TSTERR ) 257 $ CALL CERRHE( PATH, NOUT ) 258 INFOT = 0 259* 260* Set the minimum block size for which the block routine should 261* be used, which will be later returned by ILAENV 262* 263 CALL XLAENV( 2, 2 ) 264* 265* Do for each value of N in NVAL 266* 267 DO 180 IN = 1, NN 268 N = NVAL( IN ) 269 LDA = MAX( N, 1 ) 270 XTYPE = 'N' 271 NIMAT = NTYPES 272 IF( N.LE.0 ) 273 $ NIMAT = 1 274* 275 IZERO = 0 276* 277* Do for each value of matrix type IMAT 278* 279 DO 170 IMAT = 1, NIMAT 280* 281* Do the tests only if DOTYPE( IMAT ) is true. 282* 283 IF( .NOT.DOTYPE( IMAT ) ) 284 $ GO TO 170 285* 286* Skip types 3, 4, 5, or 6 if the matrix size is too small. 287* 288 ZEROT = IMAT.GE.3 .AND. IMAT.LE.6 289 IF( ZEROT .AND. N.LT.IMAT-2 ) 290 $ GO TO 170 291* 292* Do first for UPLO = 'U', then for UPLO = 'L' 293* 294 DO 160 IUPLO = 1, 2 295 UPLO = UPLOS( IUPLO ) 296* 297* Begin generate test matrix A. 298* 299* 300* Set up parameters with CLATB4 for the matrix generator 301* based on the type of matrix to be generated. 302* 303 CALL CLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE, 304 $ CNDNUM, DIST ) 305* 306* Generate a matrix with CLATMS. 307* 308 SRNAMT = 'CLATMS' 309 CALL CLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, 310 $ CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK, 311 $ INFO ) 312* 313* Check error code from CLATMS and handle error. 314* 315 IF( INFO.NE.0 ) THEN 316 CALL ALAERH( PATH, 'CLATMS', INFO, 0, UPLO, N, N, -1, 317 $ -1, -1, IMAT, NFAIL, NERRS, NOUT ) 318* 319* Skip all tests for this generated matrix 320* 321 GO TO 160 322 END IF 323* 324* For matrix types 3-6, zero one or more rows and 325* columns of the matrix to test that INFO is returned 326* correctly. 327* 328 IF( ZEROT ) THEN 329 IF( IMAT.EQ.3 ) THEN 330 IZERO = 1 331 ELSE IF( IMAT.EQ.4 ) THEN 332 IZERO = N 333 ELSE 334 IZERO = N / 2 + 1 335 END IF 336* 337 IF( IMAT.LT.6 ) THEN 338* 339* Set row and column IZERO to zero. 340* 341 IF( IUPLO.EQ.1 ) THEN 342 IOFF = ( IZERO-1 )*LDA 343 DO 20 I = 1, IZERO - 1 344 A( IOFF+I ) = CZERO 345 20 CONTINUE 346 IOFF = IOFF + IZERO 347 DO 30 I = IZERO, N 348 A( IOFF ) = CZERO 349 IOFF = IOFF + LDA 350 30 CONTINUE 351 ELSE 352 IOFF = IZERO 353 DO 40 I = 1, IZERO - 1 354 A( IOFF ) = CZERO 355 IOFF = IOFF + LDA 356 40 CONTINUE 357 IOFF = IOFF - IZERO 358 DO 50 I = IZERO, N 359 A( IOFF+I ) = CZERO 360 50 CONTINUE 361 END IF 362 ELSE 363 IF( IUPLO.EQ.1 ) THEN 364* 365* Set the first IZERO rows and columns to zero. 366* 367 IOFF = 0 368 DO 70 J = 1, N 369 I2 = MIN( J, IZERO ) 370 DO 60 I = 1, I2 371 A( IOFF+I ) = CZERO 372 60 CONTINUE 373 IOFF = IOFF + LDA 374 70 CONTINUE 375 ELSE 376* 377* Set the last IZERO rows and columns to zero. 378* 379 IOFF = 0 380 DO 90 J = 1, N 381 I1 = MAX( J, IZERO ) 382 DO 80 I = I1, N 383 A( IOFF+I ) = CZERO 384 80 CONTINUE 385 IOFF = IOFF + LDA 386 90 CONTINUE 387 END IF 388 END IF 389 ELSE 390 IZERO = 0 391 END IF 392* 393* Set the imaginary part of the diagonals. 394* 395 CALL CLAIPD( N, A, LDA+1, 0 ) 396* 397* End generate test matrix A. 398* 399* 400* Do for each value of NB in NBVAL 401* 402 DO 150 INB = 1, NNB 403* 404* Set the optimal blocksize, which will be later 405* returned by ILAENV. 406* 407 NB = NBVAL( INB ) 408 CALL XLAENV( 1, NB ) 409* 410* Copy the test matrix A into matrix AFAC which 411* will be factorized in place. This is needed to 412* preserve the test matrix A for subsequent tests. 413* 414 CALL CLACPY( UPLO, N, N, A, LDA, AFAC, LDA ) 415* 416* Compute the L*D*L**T or U*D*U**T factorization of the 417* matrix. IWORK stores details of the interchanges and 418* the block structure of D. AINV is a work array for 419* block factorization, LWORK is the length of AINV. 420* 421 LWORK = MAX( 2, NB )*LDA 422 SRNAMT = 'CHETRF' 423 CALL CHETRF( UPLO, N, AFAC, LDA, IWORK, AINV, LWORK, 424 $ INFO ) 425* 426* Adjust the expected value of INFO to account for 427* pivoting. 428* 429 K = IZERO 430 IF( K.GT.0 ) THEN 431 100 CONTINUE 432 IF( IWORK( K ).LT.0 ) THEN 433 IF( IWORK( K ).NE.-K ) THEN 434 K = -IWORK( K ) 435 GO TO 100 436 END IF 437 ELSE IF( IWORK( K ).NE.K ) THEN 438 K = IWORK( K ) 439 GO TO 100 440 END IF 441 END IF 442* 443* Check error code from CHETRF and handle error. 444* 445 IF( INFO.NE.K ) 446 $ CALL ALAERH( PATH, 'CHETRF', INFO, K, UPLO, N, N, 447 $ -1, -1, NB, IMAT, NFAIL, NERRS, NOUT ) 448* 449* Set the condition estimate flag if the INFO is not 0. 450* 451 IF( INFO.NE.0 ) THEN 452 TRFCON = .TRUE. 453 ELSE 454 TRFCON = .FALSE. 455 END IF 456* 457*+ TEST 1 458* Reconstruct matrix from factors and compute residual. 459* 460 CALL CHET01( UPLO, N, A, LDA, AFAC, LDA, IWORK, AINV, 461 $ LDA, RWORK, RESULT( 1 ) ) 462 NT = 1 463* 464*+ TEST 2 465* Form the inverse and compute the residual, 466* if the factorization was competed without INFO > 0 467* (i.e. there is no zero rows and columns). 468* Do it only for the first block size. 469* 470 IF( INB.EQ.1 .AND. .NOT.TRFCON ) THEN 471 CALL CLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA ) 472 SRNAMT = 'CHETRI2' 473 LWORK = (N+NB+1)*(NB+3) 474 CALL CHETRI2( UPLO, N, AINV, LDA, IWORK, WORK, 475 $ LWORK, INFO ) 476* 477* Check error code from CHETRI2 and handle error. 478* 479 IF( INFO.NE.0 ) 480 $ CALL ALAERH( PATH, 'CHETRI2', INFO, -1, UPLO, N, 481 $ N, -1, -1, -1, IMAT, NFAIL, NERRS, 482 $ NOUT ) 483* 484* Compute the residual for a symmetric matrix times 485* its inverse. 486* 487 CALL CPOT03( UPLO, N, A, LDA, AINV, LDA, WORK, LDA, 488 $ RWORK, RCONDC, RESULT( 2 ) ) 489 NT = 2 490 END IF 491* 492* Print information about the tests that did not pass 493* the threshold. 494* 495 DO 110 K = 1, NT 496 IF( RESULT( K ).GE.THRESH ) THEN 497 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 498 $ CALL ALAHD( NOUT, PATH ) 499 WRITE( NOUT, FMT = 9999 )UPLO, N, NB, IMAT, K, 500 $ RESULT( K ) 501 NFAIL = NFAIL + 1 502 END IF 503 110 CONTINUE 504 NRUN = NRUN + NT 505* 506* Skip the other tests if this is not the first block 507* size. 508* 509 IF( INB.GT.1 ) 510 $ GO TO 150 511* 512* Do only the condition estimate if INFO is not 0. 513* 514 IF( TRFCON ) THEN 515 RCONDC = ZERO 516 GO TO 140 517 END IF 518* 519* Do for each value of NRHS in NSVAL. 520* 521 DO 130 IRHS = 1, NNS 522 NRHS = NSVAL( IRHS ) 523* 524*+ TEST 3 (Using TRS) 525* Solve and compute residual for A * X = B. 526* 527* Choose a set of NRHS random solution vectors 528* stored in XACT and set up the right hand side B 529* 530 SRNAMT = 'CLARHS' 531 CALL CLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU, 532 $ NRHS, A, LDA, XACT, LDA, B, LDA, 533 $ ISEED, INFO ) 534 CALL CLACPY( 'Full', N, NRHS, B, LDA, X, LDA ) 535* 536 SRNAMT = 'CHETRS' 537 CALL CHETRS( UPLO, N, NRHS, AFAC, LDA, IWORK, X, 538 $ LDA, INFO ) 539* 540* Check error code from CHETRS and handle error. 541* 542 IF( INFO.NE.0 ) 543 $ CALL ALAERH( PATH, 'CHETRS', INFO, 0, UPLO, N, 544 $ N, -1, -1, NRHS, IMAT, NFAIL, 545 $ NERRS, NOUT ) 546* 547 CALL CLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA ) 548* 549* Compute the residual for the solution 550* 551 CALL CPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK, 552 $ LDA, RWORK, RESULT( 3 ) ) 553* 554*+ TEST 4 (Using TRS2) 555* Solve and compute residual for A * X = B. 556* 557* Choose a set of NRHS random solution vectors 558* stored in XACT and set up the right hand side B 559* 560 SRNAMT = 'CLARHS' 561 CALL CLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU, 562 $ NRHS, A, LDA, XACT, LDA, B, LDA, 563 $ ISEED, INFO ) 564 CALL CLACPY( 'Full', N, NRHS, B, LDA, X, LDA ) 565* 566 SRNAMT = 'CHETRS2' 567 CALL CHETRS2( UPLO, N, NRHS, AFAC, LDA, IWORK, X, 568 $ LDA, WORK, INFO ) 569* 570* Check error code from CHETRS2 and handle error. 571* 572 IF( INFO.NE.0 ) 573 $ CALL ALAERH( PATH, 'CHETRS2', INFO, 0, UPLO, N, 574 $ N, -1, -1, NRHS, IMAT, NFAIL, 575 $ NERRS, NOUT ) 576* 577 CALL CLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA ) 578* 579* Compute the residual for the solution 580* 581 CALL CPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK, 582 $ LDA, RWORK, RESULT( 4 ) ) 583* 584*+ TEST 5 585* Check solution from generated exact solution. 586* 587 CALL CGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC, 588 $ RESULT( 5 ) ) 589* 590*+ TESTS 6, 7, and 8 591* Use iterative refinement to improve the solution. 592* 593 SRNAMT = 'CHERFS' 594 CALL CHERFS( UPLO, N, NRHS, A, LDA, AFAC, LDA, 595 $ IWORK, B, LDA, X, LDA, RWORK, 596 $ RWORK( NRHS+1 ), WORK, 597 $ RWORK( 2*NRHS+1 ), INFO ) 598* 599* Check error code from CHERFS and handle error. 600* 601 IF( INFO.NE.0 ) 602 $ CALL ALAERH( PATH, 'CHERFS', INFO, 0, UPLO, N, 603 $ N, -1, -1, NRHS, IMAT, NFAIL, 604 $ NERRS, NOUT ) 605* 606 CALL CGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC, 607 $ RESULT( 6 ) ) 608 CALL CPOT05( UPLO, N, NRHS, A, LDA, B, LDA, X, LDA, 609 $ XACT, LDA, RWORK, RWORK( NRHS+1 ), 610 $ RESULT( 7 ) ) 611* 612* Print information about the tests that did not pass 613* the threshold. 614* 615 DO 120 K = 3, 8 616 IF( RESULT( K ).GE.THRESH ) THEN 617 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 618 $ CALL ALAHD( NOUT, PATH ) 619 WRITE( NOUT, FMT = 9998 )UPLO, N, NRHS, 620 $ IMAT, K, RESULT( K ) 621 NFAIL = NFAIL + 1 622 END IF 623 120 CONTINUE 624 NRUN = NRUN + 6 625* 626* End do for each value of NRHS in NSVAL. 627* 628 130 CONTINUE 629* 630*+ TEST 9 631* Get an estimate of RCOND = 1/CNDNUM. 632* 633 140 CONTINUE 634 ANORM = CLANHE( '1', UPLO, N, A, LDA, RWORK ) 635 SRNAMT = 'CHECON' 636 CALL CHECON( UPLO, N, AFAC, LDA, IWORK, ANORM, RCOND, 637 $ WORK, INFO ) 638* 639* Check error code from CHECON and handle error. 640* 641 IF( INFO.NE.0 ) 642 $ CALL ALAERH( PATH, 'CHECON', INFO, 0, UPLO, N, N, 643 $ -1, -1, -1, IMAT, NFAIL, NERRS, NOUT ) 644* 645* Compute the test ratio to compare values of RCOND 646* 647 RESULT( 9 ) = SGET06( RCOND, RCONDC ) 648* 649* Print information about the tests that did not pass 650* the threshold. 651* 652 IF( RESULT( 9 ).GE.THRESH ) THEN 653 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 654 $ CALL ALAHD( NOUT, PATH ) 655 WRITE( NOUT, FMT = 9997 )UPLO, N, IMAT, 8, 656 $ RESULT( 9 ) 657 NFAIL = NFAIL + 1 658 END IF 659 NRUN = NRUN + 1 660 150 CONTINUE 661 160 CONTINUE 662 170 CONTINUE 663 180 CONTINUE 664* 665* Print a summary of the results. 666* 667 CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS ) 668* 669 9999 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ', NB =', I4, ', type ', 670 $ I2, ', test ', I2, ', ratio =', G12.5 ) 671 9998 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ', NRHS=', I3, ', type ', 672 $ I2, ', test(', I2, ') =', G12.5 ) 673 9997 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ',', 10X, ' type ', I2, 674 $ ', test(', I2, ') =', G12.5 ) 675 RETURN 676* 677* End of CCHKHE 678* 679 END 680