TESTING/LIN/cchkaa.f

   1 *> \brief \b CCHKAA
   2 *
   3 *  =========== DOCUMENTATION ===========
   4 *
   5 * Online html documentation available at
   6 *            http://www.netlib.org/lapack/explore-html/
   7 *
   8 *  Definition:
   9 *  ===========
  10 *
  11 *       PROGRAM CCHKAA
  12 *
  13 *
  14 *> \par Purpose:
  15 *  =============
  16 *>
  17 *> \verbatim
  18 *>
  19 *> CCHKAA is the main test program for the COMPLEX linear equation
  20 *> routines.
  21 *>
  22 *> The program must be driven by a short data file. The first 15 records
  23 *> (not including the first comment  line) specify problem dimensions
  24 *> and program options using list-directed input. The remaining lines
  25 *> specify the LAPACK test paths and the number of matrix types to use
  26 *> in testing.  An annotated example of a data file can be obtained by
  27 *> deleting the first 3 characters from the following 42 lines:
  28 *> Data file for testing COMPLEX LAPACK linear equation routines
  29 *> 7                      Number of values of M
  30 *> 0 1 2 3 5 10 16        Values of M (row dimension)
  31 *> 7                      Number of values of N
  32 *> 0 1 2 3 5 10 16        Values of N (column dimension)
  33 *> 1                      Number of values of NRHS
  34 *> 2                      Values of NRHS (number of right hand sides)
  35 *> 5                      Number of values of NB
  36 *> 1 3 3 3 20             Values of NB (the blocksize)
  37 *> 1 0 5 9 1              Values of NX (crossover point)
  38 *> 3                      Number of values of RANK
  39 *> 30 50 90               Values of rank (as a % of N)
  40 *> 30.0                   Threshold value of test ratio
  41 *> T                      Put T to test the LAPACK routines
  42 *> T                      Put T to test the driver routines
  43 *> T                      Put T to test the error exits
  44 *> CGE   11               List types on next line if 0 < NTYPES < 11
  45 *> CGB    8               List types on next line if 0 < NTYPES <  8
  46 *> CGT   12               List types on next line if 0 < NTYPES < 12
  47 *> CPO    9               List types on next line if 0 < NTYPES <  9
  48 *> CPO    9               List types on next line if 0 < NTYPES <  9
  49 *> CPP    9               List types on next line if 0 < NTYPES <  9
  50 *> CPB    8               List types on next line if 0 < NTYPES <  8
  51 *> CPT   12               List types on next line if 0 < NTYPES < 12
  52 *> CHE   10               List types on next line if 0 < NTYPES < 10
  53 *> CHR   10               List types on next line if 0 < NTYPES < 10
  54 *> CHP   10               List types on next line if 0 < NTYPES < 10
  55 *> CSY   11               List types on next line if 0 < NTYPES < 11
  56 *> CSR   11               List types on next line if 0 < NTYPES < 11
  57 *> CSP   11               List types on next line if 0 < NTYPES < 11
  58 *> CTR   18               List types on next line if 0 < NTYPES < 18
  59 *> CTP   18               List types on next line if 0 < NTYPES < 18
  60 *> CTB   17               List types on next line if 0 < NTYPES < 17
  61 *> CQR    8               List types on next line if 0 < NTYPES <  8
  62 *> CRQ    8               List types on next line if 0 < NTYPES <  8
  63 *> CLQ    8               List types on next line if 0 < NTYPES <  8
  64 *> CQL    8               List types on next line if 0 < NTYPES <  8
  65 *> CQP    6               List types on next line if 0 < NTYPES <  6
  66 *> CTZ    3               List types on next line if 0 < NTYPES <  3
  67 *> CLS    6               List types on next line if 0 < NTYPES <  6
  68 *> CEQ
  69 *> CQT
  70 *> CQX
  71 *> \endverbatim
  72 *
  73 *  Parameters:
  74 *  ==========
  75 *
  76 *> \verbatim
  77 *>  NMAX    INTEGER
  78 *>          The maximum allowable value for M and N.
  79 *>
  80 *>  MAXIN   INTEGER
  81 *>          The number of different values that can be used for each of
  82 *>          M, N, NRHS, NB, NX and RANK
  83 *>
  84 *>  MAXRHS  INTEGER
  85 *>          The maximum number of right hand sides
  86 *>
  87 *>  MATMAX  INTEGER
  88 *>          The maximum number of matrix types to use for testing
  89 *>
  90 *>  NIN     INTEGER
  91 *>          The unit number for input
  92 *>
  93 *>  NOUT    INTEGER
  94 *>          The unit number for output
  95 *> \endverbatim
  96 *
  97 *  Authors:
  98 *  ========
  99 *
 100 *> \author Univ. of Tennessee
 101 *> \author Univ. of California Berkeley
 102 *> \author Univ. of Colorado Denver
 103 *> \author NAG Ltd.
 104 *
 105 *> \date November 2015
 106 *
 107 *> \ingroup complex_lin
 108 *
 109 *  =====================================================================
 110       PROGRAM CCHKAA
 111 *
 112 *  -- LAPACK test routine (version 3.6.0) --
 113 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 114 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 115 *     November 2015
 116 *
 117 *  =====================================================================
 118 *
 119 *     .. Parameters ..
 120       INTEGER            NMAX
 121       PARAMETER          ( NMAX = 132 )
 122       INTEGER            MAXIN
 123       PARAMETER          ( MAXIN = 12 )
 124       INTEGER            MAXRHS
 125       PARAMETER          ( MAXRHS = 16 )
 126       INTEGER            MATMAX
 127       PARAMETER          ( MATMAX = 30 )
 128       INTEGER            NIN, NOUT
 129       PARAMETER          ( NIN = 5, NOUT = 6 )
 130       INTEGER            KDMAX
 131       PARAMETER          ( KDMAX = NMAX+( NMAX+1 ) / 4 )
 132 *     ..
 133 *     .. Local Scalars ..
 134       LOGICAL            FATAL, TSTCHK, TSTDRV, TSTERR
 135       CHARACTER          C1
 136       CHARACTER*2        C2
 137       CHARACTER*3        PATH
 138       CHARACTER*10       INTSTR
 139       CHARACTER*72       ALINE
 140       INTEGER            I, IC, J, K, LA, LAFAC, LDA, NB, NM, NMATS, NN,
 141      $                   NNB, NNB2, NNS, NRHS, NTYPES, NRANK,
 142      $                   VERS_MAJOR, VERS_MINOR, VERS_PATCH
 143       REAL               EPS, S1, S2, THREQ, THRESH
 144 *     ..
 145 *     .. Local Arrays ..
 146       LOGICAL            DOTYPE( MATMAX )
 147       INTEGER            IWORK( 25*NMAX ), MVAL( MAXIN ),
 148      $                   NBVAL( MAXIN ), NBVAL2( MAXIN ),
 149      $                   NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ),
 150      $                   RANKVAL( MAXIN ), PIV( NMAX )
 151       REAL               RWORK( 150*NMAX+2*MAXRHS ), S( 2*NMAX )
 152       COMPLEX            A( ( KDMAX+1 )*NMAX, 7 ), B( NMAX*MAXRHS, 4 ),
 153      $                   WORK( NMAX, NMAX+MAXRHS+10 )
 154 *     ..
 155 *     .. External Functions ..
 156       LOGICAL            LSAME, LSAMEN
 157       REAL               SECOND, SLAMCH
 158       EXTERNAL           LSAME, LSAMEN, SECOND, SLAMCH
 159 *     ..
 160 *     .. External Subroutines ..
 161       EXTERNAL           ALAREQ, CCHKEQ, CCHKGB, CCHKGE, CCHKGT, CCHKHE,
 162      $                   CCHKHE_ROOK, CCHKHP, CCHKLQ, CCHKPB, CCHKPO,
 163      $                   CCHKPS, CCHKPP, CCHKPT, CCHKQ3, CCHKQL,
 164      $                   CCHKQR, CCHKRQ, CCHKSP, CCHKSY, CCHKSY_ROOK,
 165      $                   CCHKTB, CCHKTP, CCHKTR, CCHKTZ, CDRVGB, CDRVGE,
 166      $                   CDRVGT, CDRVHE, CDRVHE_ROOK, CDRVHP, CDRVLS,
 167      $                   CDRVPB, CDRVPO, CDRVPP, CDRVPT, CDRVSP, CDRVSY,
 168      $                   CDRVSY_ROOK, ILAVER, CCHKQRT, CCHKQRTP
 169
 170 *     ..
 171 *     .. Scalars in Common ..
 172       LOGICAL            LERR, OK
 173       CHARACTER*32       SRNAMT
 174       INTEGER            INFOT, NUNIT
 175 *     ..
 176 *     .. Arrays in Common ..
 177       INTEGER            IPARMS( 100 )
 178 *     ..
 179 *     .. Common blocks ..
 180       COMMON             / CLAENV / IPARMS
 181       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
 182       COMMON             / SRNAMC / SRNAMT
 183 *     ..
 184 *     .. Data statements ..
 185       DATA               THREQ / 2.0 / , INTSTR / '0123456789' /
 186 *     ..
 187 *     .. Executable Statements ..
 188 *
 189       S1 = SECOND( )
 190       LDA = NMAX
 191       FATAL = .FALSE.
 192 *
 193 *     Read a dummy line.
 194 *
 195       READ( NIN, FMT = * )
 196 *
 197 *     Report values of parameters.
 198 *
 199       CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH )
 200       WRITE( NOUT, FMT = 9994 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH
 201 *
 202 *     Read the values of M
 203 *
 204       READ( NIN, FMT = * )NM
 205       IF( NM.LT.1 ) THEN
 206          WRITE( NOUT, FMT = 9996 )' NM ', NM, 1
 207          NM = 0
 208          FATAL = .TRUE.
 209       ELSE IF( NM.GT.MAXIN ) THEN
 210          WRITE( NOUT, FMT = 9995 )' NM ', NM, MAXIN
 211          NM = 0
 212          FATAL = .TRUE.
 213       END IF
 214       READ( NIN, FMT = * )( MVAL( I ), I = 1, NM )
 215       DO 10 I = 1, NM
 216          IF( MVAL( I ).LT.0 ) THEN
 217             WRITE( NOUT, FMT = 9996 )' M  ', MVAL( I ), 0
 218             FATAL = .TRUE.
 219          ELSE IF( MVAL( I ).GT.NMAX ) THEN
 220             WRITE( NOUT, FMT = 9995 )' M  ', MVAL( I ), NMAX
 221             FATAL = .TRUE.
 222          END IF
 223    10 CONTINUE
 224       IF( NM.GT.0 )
 225      $   WRITE( NOUT, FMT = 9993 )'M   ', ( MVAL( I ), I = 1, NM )
 226 *
 227 *     Read the values of N
 228 *
 229       READ( NIN, FMT = * )NN
 230       IF( NN.LT.1 ) THEN
 231          WRITE( NOUT, FMT = 9996 )' NN ', NN, 1
 232          NN = 0
 233          FATAL = .TRUE.
 234       ELSE IF( NN.GT.MAXIN ) THEN
 235          WRITE( NOUT, FMT = 9995 )' NN ', NN, MAXIN
 236          NN = 0
 237          FATAL = .TRUE.
 238       END IF
 239       READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
 240       DO 20 I = 1, NN
 241          IF( NVAL( I ).LT.0 ) THEN
 242             WRITE( NOUT, FMT = 9996 )' N  ', NVAL( I ), 0
 243             FATAL = .TRUE.
 244          ELSE IF( NVAL( I ).GT.NMAX ) THEN
 245             WRITE( NOUT, FMT = 9995 )' N  ', NVAL( I ), NMAX
 246             FATAL = .TRUE.
 247          END IF
 248    20 CONTINUE
 249       IF( NN.GT.0 )
 250      $   WRITE( NOUT, FMT = 9993 )'N   ', ( NVAL( I ), I = 1, NN )
 251 *
 252 *     Read the values of NRHS
 253 *
 254       READ( NIN, FMT = * )NNS
 255       IF( NNS.LT.1 ) THEN
 256          WRITE( NOUT, FMT = 9996 )' NNS', NNS, 1
 257          NNS = 0
 258          FATAL = .TRUE.
 259       ELSE IF( NNS.GT.MAXIN ) THEN
 260          WRITE( NOUT, FMT = 9995 )' NNS', NNS, MAXIN
 261          NNS = 0
 262          FATAL = .TRUE.
 263       END IF
 264       READ( NIN, FMT = * )( NSVAL( I ), I = 1, NNS )
 265       DO 30 I = 1, NNS
 266          IF( NSVAL( I ).LT.0 ) THEN
 267             WRITE( NOUT, FMT = 9996 )'NRHS', NSVAL( I ), 0
 268             FATAL = .TRUE.
 269          ELSE IF( NSVAL( I ).GT.MAXRHS ) THEN
 270             WRITE( NOUT, FMT = 9995 )'NRHS', NSVAL( I ), MAXRHS
 271             FATAL = .TRUE.
 272          END IF
 273    30 CONTINUE
 274       IF( NNS.GT.0 )
 275      $   WRITE( NOUT, FMT = 9993 )'NRHS', ( NSVAL( I ), I = 1, NNS )
 276 *
 277 *     Read the values of NB
 278 *
 279       READ( NIN, FMT = * )NNB
 280       IF( NNB.LT.1 ) THEN
 281          WRITE( NOUT, FMT = 9996 )'NNB ', NNB, 1
 282          NNB = 0
 283          FATAL = .TRUE.
 284       ELSE IF( NNB.GT.MAXIN ) THEN
 285          WRITE( NOUT, FMT = 9995 )'NNB ', NNB, MAXIN
 286          NNB = 0
 287          FATAL = .TRUE.
 288       END IF
 289       READ( NIN, FMT = * )( NBVAL( I ), I = 1, NNB )
 290       DO 40 I = 1, NNB
 291          IF( NBVAL( I ).LT.0 ) THEN
 292             WRITE( NOUT, FMT = 9996 )' NB ', NBVAL( I ), 0
 293             FATAL = .TRUE.
 294          END IF
 295    40 CONTINUE
 296       IF( NNB.GT.0 )
 297      $   WRITE( NOUT, FMT = 9993 )'NB  ', ( NBVAL( I ), I = 1, NNB )
 298 *
 299 *     Set NBVAL2 to be the set of unique values of NB
 300 *
 301       NNB2 = 0
 302       DO 60 I = 1, NNB
 303          NB = NBVAL( I )
 304          DO 50 J = 1, NNB2
 305             IF( NB.EQ.NBVAL2( J ) )
 306      $         GO TO 60
 307    50    CONTINUE
 308          NNB2 = NNB2 + 1
 309          NBVAL2( NNB2 ) = NB
 310    60 CONTINUE
 311 *
 312 *     Read the values of NX
 313 *
 314       READ( NIN, FMT = * )( NXVAL( I ), I = 1, NNB )
 315       DO 70 I = 1, NNB
 316          IF( NXVAL( I ).LT.0 ) THEN
 317             WRITE( NOUT, FMT = 9996 )' NX ', NXVAL( I ), 0
 318             FATAL = .TRUE.
 319          END IF
 320    70 CONTINUE
 321       IF( NNB.GT.0 )
 322      $   WRITE( NOUT, FMT = 9993 )'NX  ', ( NXVAL( I ), I = 1, NNB )
 323 *
 324 *     Read the values of RANKVAL
 325 *
 326       READ( NIN, FMT = * )NRANK
 327       IF( NN.LT.1 ) THEN
 328          WRITE( NOUT, FMT = 9996 )' NRANK ', NRANK, 1
 329          NRANK = 0
 330          FATAL = .TRUE.
 331       ELSE IF( NN.GT.MAXIN ) THEN
 332          WRITE( NOUT, FMT = 9995 )' NRANK ', NRANK, MAXIN
 333          NRANK = 0
 334          FATAL = .TRUE.
 335       END IF
 336       READ( NIN, FMT = * )( RANKVAL( I ), I = 1, NRANK )
 337       DO I = 1, NRANK
 338          IF( RANKVAL( I ).LT.0 ) THEN
 339             WRITE( NOUT, FMT = 9996 )' RANK  ', RANKVAL( I ), 0
 340             FATAL = .TRUE.
 341          ELSE IF( RANKVAL( I ).GT.100 ) THEN
 342             WRITE( NOUT, FMT = 9995 )' RANK  ', RANKVAL( I ), 100
 343             FATAL = .TRUE.
 344          END IF
 345       END DO
 346       IF( NRANK.GT.0 )
 347      $   WRITE( NOUT, FMT = 9993 )'RANK % OF N',
 348      $   ( RANKVAL( I ), I = 1, NRANK )
 349 *
 350 *     Read the threshold value for the test ratios.
 351 *
 352       READ( NIN, FMT = * )THRESH
 353       WRITE( NOUT, FMT = 9992 )THRESH
 354 *
 355 *     Read the flag that indicates whether to test the LAPACK routines.
 356 *
 357       READ( NIN, FMT = * )TSTCHK
 358 *
 359 *     Read the flag that indicates whether to test the driver routines.
 360 *
 361       READ( NIN, FMT = * )TSTDRV
 362 *
 363 *     Read the flag that indicates whether to test the error exits.
 364 *
 365       READ( NIN, FMT = * )TSTERR
 366 *
 367       IF( FATAL ) THEN
 368          WRITE( NOUT, FMT = 9999 )
 369          STOP
 370       END IF
 371 *
 372 *     Calculate and print the machine dependent constants.
 373 *
 374       EPS = SLAMCH( 'Underflow threshold' )
 375       WRITE( NOUT, FMT = 9991 )'underflow', EPS
 376       EPS = SLAMCH( 'Overflow threshold' )
 377       WRITE( NOUT, FMT = 9991 )'overflow ', EPS
 378       EPS = SLAMCH( 'Epsilon' )
 379       WRITE( NOUT, FMT = 9991 )'precision', EPS
 380       WRITE( NOUT, FMT = * )
 381       NRHS = NSVAL( 1 )
 382 *
 383    80 CONTINUE
 384 *
 385 *     Read a test path and the number of matrix types to use.
 386 *
 387       READ( NIN, FMT = '(A72)', END = 140 )ALINE
 388       PATH = ALINE( 1: 3 )
 389       NMATS = MATMAX
 390       I = 3
 391    90 CONTINUE
 392       I = I + 1
 393       IF( I.GT.72 )
 394      $   GO TO 130
 395       IF( ALINE( I: I ).EQ.' ' )
 396      $   GO TO 90
 397       NMATS = 0
 398   100 CONTINUE
 399       C1 = ALINE( I: I )
 400       DO 110 K = 1, 10
 401          IF( C1.EQ.INTSTR( K: K ) ) THEN
 402             IC = K - 1
 403             GO TO 120
 404          END IF
 405   110 CONTINUE
 406       GO TO 130
 407   120 CONTINUE
 408       NMATS = NMATS*10 + IC
 409       I = I + 1
 410       IF( I.GT.72 )
 411      $   GO TO 130
 412       GO TO 100
 413   130 CONTINUE
 414       C1 = PATH( 1: 1 )
 415       C2 = PATH( 2: 3 )
 416 *
 417 *     Check first character for correct precision.
 418 *
 419       IF( .NOT.LSAME( C1, 'Complex precision' ) ) THEN
 420          WRITE( NOUT, FMT = 9990 )PATH
 421 *
 422       ELSE IF( NMATS.LE.0 ) THEN
 423 *
 424 *        Check for a positive number of tests requested.
 425 *
 426          WRITE( NOUT, FMT = 9989 )PATH
 427 *
 428       ELSE IF( LSAMEN( 2, C2, 'GE' ) ) THEN
 429 *
 430 *        GE:  general matrices
 431 *
 432          NTYPES = 11
 433          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 434 *
 435          IF( TSTCHK ) THEN
 436             CALL CCHKGE( DOTYPE, NM, MVAL, NN, NVAL, NNB2, NBVAL2, NNS,
 437      $                   NSVAL, THRESH, TSTERR, LDA, A( 1, 1 ),
 438      $                   A( 1, 2 ), A( 1, 3 ), B( 1, 1 ), B( 1, 2 ),
 439      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
 440          ELSE
 441             WRITE( NOUT, FMT = 9989 )PATH
 442          END IF
 443 *
 444          IF( TSTDRV ) THEN
 445             CALL CDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 446      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 447      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
 448      $                   RWORK, IWORK, NOUT )
 449          ELSE
 450             WRITE( NOUT, FMT = 9988 )PATH
 451          END IF
 452 *
 453       ELSE IF( LSAMEN( 2, C2, 'GB' ) ) THEN
 454 *
 455 *        GB:  general banded matrices
 456 *
 457          LA = ( 2*KDMAX+1 )*NMAX
 458          LAFAC = ( 3*KDMAX+1 )*NMAX
 459          NTYPES = 8
 460          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 461 *
 462          IF( TSTCHK ) THEN
 463             CALL CCHKGB( DOTYPE, NM, MVAL, NN, NVAL, NNB2, NBVAL2, NNS,
 464      $                   NSVAL, THRESH, TSTERR, A( 1, 1 ), LA,
 465      $                   A( 1, 3 ), LAFAC, B( 1, 1 ), B( 1, 2 ),
 466      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
 467          ELSE
 468             WRITE( NOUT, FMT = 9989 )PATH
 469          END IF
 470 *
 471          IF( TSTDRV ) THEN
 472             CALL CDRVGB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
 473      $                   A( 1, 1 ), LA, A( 1, 3 ), LAFAC, A( 1, 6 ),
 474      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S,
 475      $                   WORK, RWORK, IWORK, NOUT )
 476          ELSE
 477             WRITE( NOUT, FMT = 9988 )PATH
 478          END IF
 479 *
 480       ELSE IF( LSAMEN( 2, C2, 'GT' ) ) THEN
 481 *
 482 *        GT:  general tridiagonal matrices
 483 *
 484          NTYPES = 12
 485          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 486 *
 487          IF( TSTCHK ) THEN
 488             CALL CCHKGT( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 489      $                   A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
 490      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
 491          ELSE
 492             WRITE( NOUT, FMT = 9989 )PATH
 493          END IF
 494 *
 495          IF( TSTDRV ) THEN
 496             CALL CDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
 497      $                   A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
 498      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
 499          ELSE
 500             WRITE( NOUT, FMT = 9988 )PATH
 501          END IF
 502 *
 503       ELSE IF( LSAMEN( 2, C2, 'PO' ) ) THEN
 504 *
 505 *        PO:  positive definite matrices
 506 *
 507          NTYPES = 9
 508          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 509 *
 510          IF( TSTCHK ) THEN
 511             CALL CCHKPO( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 512      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 513      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
 514      $                   WORK, RWORK, NOUT )
 515          ELSE
 516             WRITE( NOUT, FMT = 9989 )PATH
 517          END IF
 518 *
 519          IF( TSTDRV ) THEN
 520             CALL CDRVPO( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 521      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 522      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
 523      $                   RWORK, NOUT )
 524          ELSE
 525             WRITE( NOUT, FMT = 9988 )PATH
 526          END IF
 527 *
 528       ELSE IF( LSAMEN( 2, C2, 'PS' ) ) THEN
 529 *
 530 *        PS:  positive semi-definite matrices
 531 *
 532          NTYPES = 9
 533 *
 534          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 535 *
 536          IF( TSTCHK ) THEN
 537             CALL CCHKPS( DOTYPE, NN, NVAL, NNB2, NBVAL2, NRANK,
 538      $                   RANKVAL, THRESH, TSTERR, LDA, A( 1, 1 ),
 539      $                   A( 1, 2 ), A( 1, 3 ), PIV, WORK, RWORK,
 540      $                   NOUT )
 541          ELSE
 542             WRITE( NOUT, FMT = 9989 )PATH
 543          END IF
 544 *
 545       ELSE IF( LSAMEN( 2, C2, 'PP' ) ) THEN
 546 *
 547 *        PP:  positive definite packed matrices
 548 *
 549          NTYPES = 9
 550          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 551 *
 552          IF( TSTCHK ) THEN
 553             CALL CCHKPP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 554      $                   LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
 555      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
 556      $                   NOUT )
 557          ELSE
 558             WRITE( NOUT, FMT = 9989 )PATH
 559          END IF
 560 *
 561          IF( TSTDRV ) THEN
 562             CALL CDRVPP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 563      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 564      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
 565      $                   RWORK, NOUT )
 566          ELSE
 567             WRITE( NOUT, FMT = 9988 )PATH
 568          END IF
 569 *
 570       ELSE IF( LSAMEN( 2, C2, 'PB' ) ) THEN
 571 *
 572 *        PB:  positive definite banded matrices
 573 *
 574          NTYPES = 8
 575          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 576 *
 577          IF( TSTCHK ) THEN
 578             CALL CCHKPB( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 579      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 580      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
 581      $                   WORK, RWORK, NOUT )
 582          ELSE
 583             WRITE( NOUT, FMT = 9989 )PATH
 584          END IF
 585 *
 586          IF( TSTDRV ) THEN
 587             CALL CDRVPB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 588      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 589      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
 590      $                   RWORK, NOUT )
 591          ELSE
 592             WRITE( NOUT, FMT = 9988 )PATH
 593          END IF
 594 *
 595       ELSE IF( LSAMEN( 2, C2, 'PT' ) ) THEN
 596 *
 597 *        PT:  positive definite tridiagonal matrices
 598 *
 599          NTYPES = 12
 600          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 601 *
 602          IF( TSTCHK ) THEN
 603             CALL CCHKPT( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 604      $                   A( 1, 1 ), S, A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
 605      $                   B( 1, 3 ), WORK, RWORK, NOUT )
 606          ELSE
 607             WRITE( NOUT, FMT = 9989 )PATH
 608          END IF
 609 *
 610          IF( TSTDRV ) THEN
 611             CALL CDRVPT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
 612      $                   A( 1, 1 ), S, A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
 613      $                   B( 1, 3 ), WORK, RWORK, NOUT )
 614          ELSE
 615             WRITE( NOUT, FMT = 9988 )PATH
 616          END IF
 617 *
 618       ELSE IF( LSAMEN( 2, C2, 'HE' ) ) THEN
 619 *
 620 *        HE:  Hermitian indefinite matrices,
 621 *             with partial (Bunch-Kaufman) pivoting algorithm
 622 *
 623          NTYPES = 10
 624          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 625 *
 626          IF( TSTCHK ) THEN
 627             CALL CCHKHE( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 628      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 629      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
 630      $                   WORK, RWORK, IWORK, NOUT )
 631          ELSE
 632             WRITE( NOUT, FMT = 9989 )PATH
 633          END IF
 634 *
 635          IF( TSTDRV ) THEN
 636             CALL CDRVHE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 637      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 638      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
 639      $                   NOUT )
 640          ELSE
 641             WRITE( NOUT, FMT = 9988 )PATH
 642          END IF
 643 *
 644       ELSE IF( LSAMEN( 2, C2, 'HR' ) ) THEN
 645 *
 646 *        HR:  Hermitian indefinite matrices,
 647 *             with "rook" (bounded Bunch-Kaufman) pivoting algorithm
 648 *
 649          NTYPES = 10
 650          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 651 *
 652          IF( TSTCHK ) THEN
 653             CALL CCHKHE_ROOK(DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 654      $                       THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 655      $                       A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
 656      $                       WORK, RWORK, IWORK, NOUT )
 657          ELSE
 658             WRITE( NOUT, FMT = 9989 )PATH
 659          END IF
 660 *
 661          IF( TSTDRV ) THEN
 662             CALL CDRVHE_ROOK( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
 663      $                        LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
 664      $                        B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK,
 665      $                        RWORK, IWORK, NOUT )
 666          ELSE
 667             WRITE( NOUT, FMT = 9988 )PATH
 668          END IF
 669 *
 670       ELSE IF( LSAMEN( 2, C2, 'HP' ) ) THEN
 671 *
 672 *        HP:  Hermitian indefinite packed matrices,
 673 *             with partial (Bunch-Kaufman) pivoting algorithm
 674 *
 675          NTYPES = 10
 676          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 677 *
 678          IF( TSTCHK ) THEN
 679             CALL CCHKHP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 680      $                   LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
 681      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
 682      $                   IWORK, NOUT )
 683          ELSE
 684             WRITE( NOUT, FMT = 9989 )PATH
 685          END IF
 686 *
 687          IF( TSTDRV ) THEN
 688             CALL CDRVHP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 689      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 690      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
 691      $                   NOUT )
 692          ELSE
 693             WRITE( NOUT, FMT = 9988 )PATH
 694          END IF
 695 *
 696       ELSE IF( LSAMEN( 2, C2, 'SY' ) ) THEN
 697 *
 698 *        SY:  symmetric indefinite matrices,
 699 *             with partial (Bunch-Kaufman) pivoting algorithm
 700 *
 701          NTYPES = 11
 702          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 703 *
 704          IF( TSTCHK ) THEN
 705             CALL CCHKSY( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 706      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 707      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
 708      $                   WORK, RWORK, IWORK, NOUT )
 709          ELSE
 710             WRITE( NOUT, FMT = 9989 )PATH
 711          END IF
 712 *
 713          IF( TSTDRV ) THEN
 714             CALL CDRVSY( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 715      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 716      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
 717      $                   NOUT )
 718          ELSE
 719             WRITE( NOUT, FMT = 9988 )PATH
 720          END IF
 721 *
 722       ELSE IF( LSAMEN( 2, C2, 'SR' ) ) THEN
 723 *
 724 *        SR:  symmetric indefinite matrices,
 725 *             with "rook" (bounded Bunch-Kaufman) pivoting algorithm
 726 *
 727          NTYPES = 11
 728          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 729 *
 730          IF( TSTCHK ) THEN
 731             CALL CCHKSY_ROOK(DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 732      $                       THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 733      $                       A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
 734      $                       WORK, RWORK, IWORK, NOUT )
 735          ELSE
 736             WRITE( NOUT, FMT = 9989 )PATH
 737          END IF
 738 *
 739          IF( TSTDRV ) THEN
 740             CALL CDRVSY_ROOK( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
 741      $                        LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
 742      $                        B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK,
 743      $                        RWORK, IWORK, NOUT )
 744          ELSE
 745             WRITE( NOUT, FMT = 9988 )PATH
 746          END IF
 747 *
 748       ELSE IF( LSAMEN( 2, C2, 'SP' ) ) THEN
 749 *
 750 *        SP:  symmetric indefinite packed matrices,
 751 *             with partial (Bunch-Kaufman) pivoting algorithm
 752 *
 753          NTYPES = 11
 754          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 755 *
 756          IF( TSTCHK ) THEN
 757             CALL CCHKSP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 758      $                   LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
 759      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
 760      $                   IWORK, NOUT )
 761          ELSE
 762             WRITE( NOUT, FMT = 9989 )PATH
 763          END IF
 764 *
 765          IF( TSTDRV ) THEN
 766             CALL CDRVSP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
 767      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
 768      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
 769      $                   NOUT )
 770          ELSE
 771             WRITE( NOUT, FMT = 9988 )PATH
 772          END IF
 773 *
 774       ELSE IF( LSAMEN( 2, C2, 'TR' ) ) THEN
 775 *
 776 *        TR:  triangular matrices
 777 *
 778          NTYPES = 18
 779          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 780 *
 781          IF( TSTCHK ) THEN
 782             CALL CCHKTR( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
 783      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
 784      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
 785      $                   NOUT )
 786          ELSE
 787             WRITE( NOUT, FMT = 9989 )PATH
 788          END IF
 789 *
 790       ELSE IF( LSAMEN( 2, C2, 'TP' ) ) THEN
 791 *
 792 *        TP:  triangular packed matrices
 793 *
 794          NTYPES = 18
 795          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 796 *
 797          IF( TSTCHK ) THEN
 798             CALL CCHKTP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 799      $                   LDA, A( 1, 1 ), A( 1, 2 ), B( 1, 1 ),
 800      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, NOUT )
 801          ELSE
 802             WRITE( NOUT, FMT = 9989 )PATH
 803          END IF
 804 *
 805       ELSE IF( LSAMEN( 2, C2, 'TB' ) ) THEN
 806 *
 807 *        TB:  triangular banded matrices
 808 *
 809          NTYPES = 17
 810          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 811 *
 812          IF( TSTCHK ) THEN
 813             CALL CCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
 814      $                   LDA, A( 1, 1 ), A( 1, 2 ), B( 1, 1 ),
 815      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, NOUT )
 816          ELSE
 817             WRITE( NOUT, FMT = 9989 )PATH
 818          END IF
 819 *
 820       ELSE IF( LSAMEN( 2, C2, 'QR' ) ) THEN
 821 *
 822 *        QR:  QR factorization
 823 *
 824          NTYPES = 8
 825          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 826 *
 827          IF( TSTCHK ) THEN
 828             CALL CCHKQR( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
 829      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
 830      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
 831      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
 832      $                   WORK, RWORK, IWORK, NOUT )
 833          ELSE
 834             WRITE( NOUT, FMT = 9989 )PATH
 835          END IF
 836 *
 837       ELSE IF( LSAMEN( 2, C2, 'LQ' ) ) THEN
 838 *
 839 *        LQ:  LQ factorization
 840 *
 841          NTYPES = 8
 842          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 843 *
 844          IF( TSTCHK ) THEN
 845             CALL CCHKLQ( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
 846      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
 847      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
 848      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
 849      $                   WORK, RWORK, NOUT )
 850          ELSE
 851             WRITE( NOUT, FMT = 9989 )PATH
 852          END IF
 853 *
 854       ELSE IF( LSAMEN( 2, C2, 'QL' ) ) THEN
 855 *
 856 *        QL:  QL factorization
 857 *
 858          NTYPES = 8
 859          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 860 *
 861          IF( TSTCHK ) THEN
 862             CALL CCHKQL( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
 863      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
 864      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
 865      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
 866      $                   WORK, RWORK, NOUT )
 867          ELSE
 868             WRITE( NOUT, FMT = 9989 )PATH
 869          END IF
 870
 871 *
 872       ELSE IF( LSAMEN( 2, C2, 'RQ' ) ) THEN
 873 *
 874 *        RQ:  RQ factorization
 875 *
 876          NTYPES = 8
 877          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 878 *
 879          IF( TSTCHK ) THEN
 880             CALL CCHKRQ( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
 881      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
 882      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
 883      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
 884      $                   WORK, RWORK, IWORK, NOUT )
 885          ELSE
 886             WRITE( NOUT, FMT = 9989 )PATH
 887          END IF
 888 *
 889       ELSE IF( LSAMEN( 2, C2, 'EQ' ) ) THEN
 890 *
 891 *        EQ:  Equilibration routines for general and positive definite
 892 *             matrices (THREQ should be between 2 and 10)
 893 *
 894          IF( TSTCHK ) THEN
 895             CALL CCHKEQ( THREQ, NOUT )
 896          ELSE
 897             WRITE( NOUT, FMT = 9989 )PATH
 898          END IF
 899 *
 900       ELSE IF( LSAMEN( 2, C2, 'TZ' ) ) THEN
 901 *
 902 *        TZ:  Trapezoidal matrix
 903 *
 904          NTYPES = 3
 905          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 906 *
 907          IF( TSTCHK ) THEN
 908             CALL CCHKTZ( DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR,
 909      $                   A( 1, 1 ), A( 1, 2 ), S( 1 ),
 910      $                   B( 1, 1 ), WORK, RWORK, NOUT )
 911          ELSE
 912             WRITE( NOUT, FMT = 9989 )PATH
 913          END IF
 914 *
 915       ELSE IF( LSAMEN( 2, C2, 'QP' ) ) THEN
 916 *
 917 *        QP:  QR factorization with pivoting
 918 *
 919          NTYPES = 6
 920          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 921 *
 922          IF( TSTCHK ) THEN
 923             CALL CCHKQ3( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
 924      $                   THRESH, A( 1, 1 ), A( 1, 2 ), S( 1 ),
 925      $                   B( 1, 1 ), WORK, RWORK, IWORK, NOUT )
 926          ELSE
 927             WRITE( NOUT, FMT = 9989 )PATH
 928          END IF
 929
 930 *
 931       ELSE IF( LSAMEN( 2, C2, 'LS' ) ) THEN
 932 *
 933 *        LS:  Least squares drivers
 934 *
 935          NTYPES = 6
 936          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
 937 *
 938          IF( TSTDRV ) THEN
 939             CALL CDRVLS( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
 940      $                   NBVAL, NXVAL, THRESH, TSTERR, A( 1, 1 ),
 941      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
 942      $                   S( 1 ), S( NMAX+1 ), WORK, RWORK, IWORK,
 943      $                   NOUT )
 944          ELSE
 945             WRITE( NOUT, FMT = 9989 )PATH
 946          END IF
 947 *
 948       ELSE IF( LSAMEN( 2, C2, 'QT' ) ) THEN
 949 *
 950 *        QT:  QRT routines for general matrices
 951 *
 952          IF( TSTCHK ) THEN
 953             CALL CCHKQRT( THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB,
 954      $                    NBVAL, NOUT )
 955          ELSE
 956             WRITE( NOUT, FMT = 9989 )PATH
 957          END IF
 958 *
 959       ELSE IF( LSAMEN( 2, C2, 'QX' ) ) THEN
 960 *
 961 *        QX:  QRT routines for triangular-pentagonal matrices
 962 *
 963          IF( TSTCHK ) THEN
 964             CALL CCHKQRTP( THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB,
 965      $                     NBVAL, NOUT )
 966          ELSE
 967             WRITE( NOUT, FMT = 9989 )PATH
 968          END IF
 969 *
 970       ELSE
 971 *
 972          WRITE( NOUT, FMT = 9990 )PATH
 973       END IF
 974 *
 975 *     Go back to get another input line.
 976 *
 977       GO TO 80
 978 *
 979 *     Branch to this line when the last record is read.
 980 *
 981   140 CONTINUE
 982       CLOSE ( NIN )
 983       S2 = SECOND( )
 984       WRITE( NOUT, FMT = 9998 )
 985       WRITE( NOUT, FMT = 9997 )S2 - S1
 986 *
 987  9999 FORMAT( / ' Execution not attempted due to input errors' )
 988  9998 FORMAT( / ' End of tests' )
 989  9997 FORMAT( ' Total time used = ', F12.2, ' seconds', / )
 990  9996 FORMAT( ' Invalid input value: ', A4, '=', I6, '; must be >=',
 991      $      I6 )
 992  9995 FORMAT( ' Invalid input value: ', A4, '=', I6, '; must be <=',
 993      $      I6 )
 994  9994 FORMAT( ' Tests of the COMPLEX LAPACK routines ',
 995      $      / ' LAPACK VERSION ', I1, '.', I1, '.', I1,
 996      $      / / ' The following parameter values will be used:' )
 997  9993 FORMAT( 4X, A4, ':  ', 10I6, / 11X, 10I6 )
 998  9992 FORMAT( / ' Routines pass computational tests if test ratio is ',
 999      $      'less than', F8.2, / )
1000  9991 FORMAT( ' Relative machine ', A, ' is taken to be', E16.6 )
1001  9990 FORMAT( / 1X, A3, ':  Unrecognized path name' )
1002  9989 FORMAT( / 1X, A3, ' routines were not tested' )
1003  9988 FORMAT( / 1X, A3, ' driver routines were not tested' )
1004 *
1005 *     End of CCHKAA
1006 *
1007       END