LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
zchkaa.f
Go to the documentation of this file.
00001 *> \brief \b ZCHKAA
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *  Definition:
00009 *  ===========
00010 *
00011 *       PROGRAM ZCHKAA
00012 * 
00013 *
00014 *> \par Purpose:
00015 *  =============
00016 *>
00017 *> \verbatim
00018 *>
00019 *> ZCHKAA is the main test program for the COMPLEX*16 linear equation
00020 *> routines.
00021 *>
00022 *> The program must be driven by a short data file. The first 15 records
00023 *> (not including the first comment  line) specify problem dimensions
00024 *> and program options using list-directed input. The remaining lines
00025 *> specify the LAPACK test paths and the number of matrix types to use
00026 *> in testing.  An annotated example of a data file can be obtained by
00027 *> deleting the first 3 characters from the following 42 lines:
00028 *> Data file for testing COMPLEX*16 LAPACK linear equation routines
00029 *> 7                      Number of values of M
00030 *> 0 1 2 3 5 10 16        Values of M (row dimension)
00031 *> 7                      Number of values of N
00032 *> 0 1 2 3 5 10 16        Values of N (column dimension)
00033 *> 1                      Number of values of NRHS
00034 *> 2                      Values of NRHS (number of right hand sides)
00035 *> 5                      Number of values of NB
00036 *> 1 3 3 3 20             Values of NB (the blocksize)
00037 *> 1 0 5 9 1              Values of NX (crossover point)
00038 *> 3                      Number of values of RANK
00039 *> 30 50 90               Values of rank (as a % of N)
00040 *> 30.0                   Threshold value of test ratio
00041 *> T                      Put T to test the LAPACK routines
00042 *> T                      Put T to test the driver routines
00043 *> T                      Put T to test the error exits
00044 *> ZGE   11               List types on next line if 0 < NTYPES < 11
00045 *> ZGB    8               List types on next line if 0 < NTYPES <  8
00046 *> ZGT   12               List types on next line if 0 < NTYPES < 12
00047 *> ZPO    9               List types on next line if 0 < NTYPES <  9
00048 *> ZPS    9               List types on next line if 0 < NTYPES <  9
00049 *> ZPP    9               List types on next line if 0 < NTYPES <  9
00050 *> ZPB    8               List types on next line if 0 < NTYPES <  8
00051 *> ZPT   12               List types on next line if 0 < NTYPES < 12
00052 *> ZHE   10               List types on next line if 0 < NTYPES < 10
00053 *> ZHP   10               List types on next line if 0 < NTYPES < 10
00054 *> ZSY   11               List types on next line if 0 < NTYPES < 11
00055 *> ZSR   11               List types on next line if 0 < NTYPES < 11
00056 *> ZSP   11               List types on next line if 0 < NTYPES < 11
00057 *> ZTR   18               List types on next line if 0 < NTYPES < 18
00058 *> ZTP   18               List types on next line if 0 < NTYPES < 18
00059 *> ZTB   17               List types on next line if 0 < NTYPES < 17
00060 *> ZQR    8               List types on next line if 0 < NTYPES <  8
00061 *> ZRQ    8               List types on next line if 0 < NTYPES <  8
00062 *> ZLQ    8               List types on next line if 0 < NTYPES <  8
00063 *> ZQL    8               List types on next line if 0 < NTYPES <  8
00064 *> ZQP    6               List types on next line if 0 < NTYPES <  6
00065 *> ZTZ    3               List types on next line if 0 < NTYPES <  3
00066 *> ZLS    6               List types on next line if 0 < NTYPES <  6
00067 *> ZEQ
00068 *> ZQT
00069 *> ZQX
00070 *> \endverbatim
00071 *
00072 *  Parameters:
00073 *  ==========
00074 *
00075 *> \verbatim
00076 *>  NMAX    INTEGER
00077 *>          The maximum allowable value for M and N.
00078 *>
00079 *>  MAXIN   INTEGER
00080 *>          The number of different values that can be used for each of
00081 *>          M, N, NRHS, NB, NX and RANK
00082 *>
00083 *>  MAXRHS  INTEGER
00084 *>          The maximum number of right hand sides
00085 *>
00086 *>  MATMAX  INTEGER
00087 *>          The maximum number of matrix types to use for testing
00088 *>
00089 *>  NIN     INTEGER
00090 *>          The unit number for input
00091 *>
00092 *>  NOUT    INTEGER
00093 *>          The unit number for output
00094 *> \endverbatim
00095 *
00096 *  Authors:
00097 *  ========
00098 *
00099 *> \author Univ. of Tennessee 
00100 *> \author Univ. of California Berkeley 
00101 *> \author Univ. of Colorado Denver 
00102 *> \author NAG Ltd. 
00103 *
00104 *> \date April 2012
00105 *
00106 *> \ingroup complex16_lin
00107 *
00108 *  =====================================================================
00109       PROGRAM ZCHKAA
00110 *
00111 *  -- LAPACK test routine (version 3.4.1) --
00112 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00113 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00114 *     April 2012
00115 *
00116 *  =====================================================================
00117 *
00118 *     .. Parameters ..
00119       INTEGER            NMAX
00120       PARAMETER          ( NMAX = 132 )
00121       INTEGER            MAXIN
00122       PARAMETER          ( MAXIN = 12 )
00123       INTEGER            MAXRHS
00124       PARAMETER          ( MAXRHS = 16 )
00125       INTEGER            MATMAX
00126       PARAMETER          ( MATMAX = 30 )
00127       INTEGER            NIN, NOUT
00128       PARAMETER          ( NIN = 5, NOUT = 6 )
00129       INTEGER            KDMAX
00130       PARAMETER          ( KDMAX = NMAX+( NMAX+1 ) / 4 )
00131 *     ..
00132 *     .. Local Scalars ..
00133       LOGICAL            FATAL, TSTCHK, TSTDRV, TSTERR
00134       CHARACTER          C1
00135       CHARACTER*2        C2
00136       CHARACTER*3        PATH
00137       CHARACTER*10       INTSTR
00138       CHARACTER*72       ALINE
00139       INTEGER            I, IC, J, K, LA, LAFAC, LDA, NB, NM, NMATS, NN,
00140      $                   NNB, NNB2, NNS, NRHS, NTYPES, NRANK,
00141      $                   VERS_MAJOR, VERS_MINOR, VERS_PATCH
00142       DOUBLE PRECISION   EPS, S1, S2, THREQ, THRESH
00143 *     ..
00144 *     .. Local Arrays ..
00145       LOGICAL            DOTYPE( MATMAX )
00146       INTEGER            IWORK( 25*NMAX ), MVAL( MAXIN ),
00147      $                   NBVAL( MAXIN ), NBVAL2( MAXIN ),
00148      $                   NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ),
00149      $                   RANKVAL( MAXIN ), PIV( NMAX )
00150       DOUBLE PRECISION   RWORK( 150*NMAX+2*MAXRHS ), S( 2*NMAX )
00151       COMPLEX*16         A( ( KDMAX+1 )*NMAX, 7 ), B( NMAX*MAXRHS, 4 ),
00152      $                   WORK( NMAX, NMAX+MAXRHS+10 )
00153 *     ..
00154 *     .. External Functions ..
00155       LOGICAL            LSAME, LSAMEN
00156       DOUBLE PRECISION   DLAMCH, DSECND
00157       EXTERNAL           LSAME, LSAMEN, DLAMCH, DSECND
00158 *     ..
00159 *     .. External Subroutines ..
00160       EXTERNAL           ALAREQ, ZCHKEQ, ZCHKGB, ZCHKGE, ZCHKGT, ZCHKHE,
00161      $                   ZCHKHP, ZCHKLQ, ZCHKPB, ZCHKPO, ZCHKPS, ZCHKPP,
00162      $                   ZCHKPT, ZCHKQ3, ZCHKQL, ZCHKQP, ZCHKQR, ZCHKRQ,
00163      $                   ZCHKSP, ZCHKSY, ZCHKTB, ZCHKTP,
00164      $                   ZCHKTR, ZCHKTZ, ZDRVGB, ZDRVGE, ZDRVGT, ZDRVHE,
00165      $                   ZDRVHP, ZDRVLS, ZDRVPB, ZDRVPO, ZDRVPP, ZDRVPT,
00166      $                   ZDRVSP, ZDRVSY, ILAVER, ZCHKQRT,
00167      $                   ZCHKQRTP
00168 *     ..
00169 *     .. Scalars in Common ..
00170       LOGICAL            LERR, OK
00171       CHARACTER*32       SRNAMT
00172       INTEGER            INFOT, NUNIT
00173 *     ..
00174 *     .. Arrays in Common ..
00175       INTEGER            IPARMS( 100 )
00176 *     ..
00177 *     .. Common blocks ..
00178       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
00179       COMMON             / SRNAMC / SRNAMT
00180       COMMON             / CLAENV / IPARMS
00181 *     ..
00182 *     .. Data statements ..
00183       DATA               THREQ / 2.0D0 / , INTSTR / '0123456789' /
00184 *     ..
00185 *     .. Executable Statements ..
00186 *
00187       S1 = DSECND( )
00188       LDA = NMAX
00189       FATAL = .FALSE.
00190 *
00191 *     Read a dummy line.
00192 *
00193       READ( NIN, FMT = * )
00194 *
00195 *     Report values of parameters.
00196 *
00197       CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH )
00198       WRITE( NOUT, FMT = 9994 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH
00199 *
00200 *     Read the values of M
00201 *
00202       READ( NIN, FMT = * )NM
00203       IF( NM.LT.1 ) THEN
00204          WRITE( NOUT, FMT = 9996 )' NM ', NM, 1
00205          NM = 0
00206          FATAL = .TRUE.
00207       ELSE IF( NM.GT.MAXIN ) THEN
00208          WRITE( NOUT, FMT = 9995 )' NM ', NM, MAXIN
00209          NM = 0
00210          FATAL = .TRUE.
00211       END IF
00212       READ( NIN, FMT = * )( MVAL( I ), I = 1, NM )
00213       DO 10 I = 1, NM
00214          IF( MVAL( I ).LT.0 ) THEN
00215             WRITE( NOUT, FMT = 9996 )' M  ', MVAL( I ), 0
00216             FATAL = .TRUE.
00217          ELSE IF( MVAL( I ).GT.NMAX ) THEN
00218             WRITE( NOUT, FMT = 9995 )' M  ', MVAL( I ), NMAX
00219             FATAL = .TRUE.
00220          END IF
00221    10 CONTINUE
00222       IF( NM.GT.0 )
00223      $   WRITE( NOUT, FMT = 9993 )'M   ', ( MVAL( I ), I = 1, NM )
00224 *
00225 *     Read the values of N
00226 *
00227       READ( NIN, FMT = * )NN
00228       IF( NN.LT.1 ) THEN
00229          WRITE( NOUT, FMT = 9996 )' NN ', NN, 1
00230          NN = 0
00231          FATAL = .TRUE.
00232       ELSE IF( NN.GT.MAXIN ) THEN
00233          WRITE( NOUT, FMT = 9995 )' NN ', NN, MAXIN
00234          NN = 0
00235          FATAL = .TRUE.
00236       END IF
00237       READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
00238       DO 20 I = 1, NN
00239          IF( NVAL( I ).LT.0 ) THEN
00240             WRITE( NOUT, FMT = 9996 )' N  ', NVAL( I ), 0
00241             FATAL = .TRUE.
00242          ELSE IF( NVAL( I ).GT.NMAX ) THEN
00243             WRITE( NOUT, FMT = 9995 )' N  ', NVAL( I ), NMAX
00244             FATAL = .TRUE.
00245          END IF
00246    20 CONTINUE
00247       IF( NN.GT.0 )
00248      $   WRITE( NOUT, FMT = 9993 )'N   ', ( NVAL( I ), I = 1, NN )
00249 *
00250 *     Read the values of NRHS
00251 *
00252       READ( NIN, FMT = * )NNS
00253       IF( NNS.LT.1 ) THEN
00254          WRITE( NOUT, FMT = 9996 )' NNS', NNS, 1
00255          NNS = 0
00256          FATAL = .TRUE.
00257       ELSE IF( NNS.GT.MAXIN ) THEN
00258          WRITE( NOUT, FMT = 9995 )' NNS', NNS, MAXIN
00259          NNS = 0
00260          FATAL = .TRUE.
00261       END IF
00262       READ( NIN, FMT = * )( NSVAL( I ), I = 1, NNS )
00263       DO 30 I = 1, NNS
00264          IF( NSVAL( I ).LT.0 ) THEN
00265             WRITE( NOUT, FMT = 9996 )'NRHS', NSVAL( I ), 0
00266             FATAL = .TRUE.
00267          ELSE IF( NSVAL( I ).GT.MAXRHS ) THEN
00268             WRITE( NOUT, FMT = 9995 )'NRHS', NSVAL( I ), MAXRHS
00269             FATAL = .TRUE.
00270          END IF
00271    30 CONTINUE
00272       IF( NNS.GT.0 )
00273      $   WRITE( NOUT, FMT = 9993 )'NRHS', ( NSVAL( I ), I = 1, NNS )
00274 *
00275 *     Read the values of NB
00276 *
00277       READ( NIN, FMT = * )NNB
00278       IF( NNB.LT.1 ) THEN
00279          WRITE( NOUT, FMT = 9996 )'NNB ', NNB, 1
00280          NNB = 0
00281          FATAL = .TRUE.
00282       ELSE IF( NNB.GT.MAXIN ) THEN
00283          WRITE( NOUT, FMT = 9995 )'NNB ', NNB, MAXIN
00284          NNB = 0
00285          FATAL = .TRUE.
00286       END IF
00287       READ( NIN, FMT = * )( NBVAL( I ), I = 1, NNB )
00288       DO 40 I = 1, NNB
00289          IF( NBVAL( I ).LT.0 ) THEN
00290             WRITE( NOUT, FMT = 9996 )' NB ', NBVAL( I ), 0
00291             FATAL = .TRUE.
00292          END IF
00293    40 CONTINUE
00294       IF( NNB.GT.0 )
00295      $   WRITE( NOUT, FMT = 9993 )'NB  ', ( NBVAL( I ), I = 1, NNB )
00296 *
00297 *     Set NBVAL2 to be the set of unique values of NB
00298 *
00299       NNB2 = 0
00300       DO 60 I = 1, NNB
00301          NB = NBVAL( I )
00302          DO 50 J = 1, NNB2
00303             IF( NB.EQ.NBVAL2( J ) )
00304      $         GO TO 60
00305    50    CONTINUE
00306          NNB2 = NNB2 + 1
00307          NBVAL2( NNB2 ) = NB
00308    60 CONTINUE
00309 *
00310 *     Read the values of NX
00311 *
00312       READ( NIN, FMT = * )( NXVAL( I ), I = 1, NNB )
00313       DO 70 I = 1, NNB
00314          IF( NXVAL( I ).LT.0 ) THEN
00315             WRITE( NOUT, FMT = 9996 )' NX ', NXVAL( I ), 0
00316             FATAL = .TRUE.
00317          END IF
00318    70 CONTINUE
00319       IF( NNB.GT.0 )
00320      $   WRITE( NOUT, FMT = 9993 )'NX  ', ( NXVAL( I ), I = 1, NNB )
00321 *
00322 *     Read the values of RANKVAL
00323 *
00324       READ( NIN, FMT = * )NRANK
00325       IF( NN.LT.1 ) THEN
00326          WRITE( NOUT, FMT = 9996 )' NRANK ', NRANK, 1
00327          NRANK = 0
00328          FATAL = .TRUE.
00329       ELSE IF( NN.GT.MAXIN ) THEN
00330          WRITE( NOUT, FMT = 9995 )' NRANK ', NRANK, MAXIN
00331          NRANK = 0
00332          FATAL = .TRUE.
00333       END IF
00334       READ( NIN, FMT = * )( RANKVAL( I ), I = 1, NRANK )
00335       DO I = 1, NRANK
00336          IF( RANKVAL( I ).LT.0 ) THEN
00337             WRITE( NOUT, FMT = 9996 )' RANK  ', RANKVAL( I ), 0
00338             FATAL = .TRUE.
00339          ELSE IF( RANKVAL( I ).GT.100 ) THEN
00340             WRITE( NOUT, FMT = 9995 )' RANK  ', RANKVAL( I ), 100
00341             FATAL = .TRUE.
00342          END IF
00343       END DO
00344       IF( NRANK.GT.0 )
00345      $   WRITE( NOUT, FMT = 9993 )'RANK % OF N',
00346      $   ( RANKVAL( I ), I = 1, NRANK )
00347 *
00348 *     Read the threshold value for the test ratios.
00349 *
00350       READ( NIN, FMT = * )THRESH
00351       WRITE( NOUT, FMT = 9992 )THRESH
00352 *
00353 *     Read the flag that indicates whether to test the LAPACK routines.
00354 *
00355       READ( NIN, FMT = * )TSTCHK
00356 *
00357 *     Read the flag that indicates whether to test the driver routines.
00358 *
00359       READ( NIN, FMT = * )TSTDRV
00360 *
00361 *     Read the flag that indicates whether to test the error exits.
00362 *
00363       READ( NIN, FMT = * )TSTERR
00364 *
00365       IF( FATAL ) THEN
00366          WRITE( NOUT, FMT = 9999 )
00367          STOP
00368       END IF
00369 *
00370 *     Calculate and print the machine dependent constants.
00371 *
00372       EPS = DLAMCH( 'Underflow threshold' )
00373       WRITE( NOUT, FMT = 9991 )'underflow', EPS
00374       EPS = DLAMCH( 'Overflow threshold' )
00375       WRITE( NOUT, FMT = 9991 )'overflow ', EPS
00376       EPS = DLAMCH( 'Epsilon' )
00377       WRITE( NOUT, FMT = 9991 )'precision', EPS
00378       WRITE( NOUT, FMT = * )
00379       NRHS = NSVAL( 1 )
00380 *
00381    80 CONTINUE
00382 *
00383 *     Read a test path and the number of matrix types to use.
00384 *
00385       READ( NIN, FMT = '(A72)', END = 140 )ALINE
00386       PATH = ALINE( 1: 3 )
00387       NMATS = MATMAX
00388       I = 3
00389    90 CONTINUE
00390       I = I + 1
00391       IF( I.GT.72 )
00392      $   GO TO 130
00393       IF( ALINE( I: I ).EQ.' ' )
00394      $   GO TO 90
00395       NMATS = 0
00396   100 CONTINUE
00397       C1 = ALINE( I: I )
00398       DO 110 K = 1, 10
00399          IF( C1.EQ.INTSTR( K: K ) ) THEN
00400             IC = K - 1
00401             GO TO 120
00402          END IF
00403   110 CONTINUE
00404       GO TO 130
00405   120 CONTINUE
00406       NMATS = NMATS*10 + IC
00407       I = I + 1
00408       IF( I.GT.72 )
00409      $   GO TO 130
00410       GO TO 100
00411   130 CONTINUE
00412       C1 = PATH( 1: 1 )
00413       C2 = PATH( 2: 3 )
00414 *
00415 *     Check first character for correct precision.
00416 *
00417       IF( .NOT.LSAME( C1, 'Zomplex precision' ) ) THEN
00418          WRITE( NOUT, FMT = 9990 )PATH
00419 *
00420       ELSE IF( NMATS.LE.0 ) THEN
00421 *
00422 *        Check for a positive number of tests requested.
00423 *
00424          WRITE( NOUT, FMT = 9989 )PATH
00425 *
00426       ELSE IF( LSAMEN( 2, C2, 'GE' ) ) THEN
00427 *
00428 *        GE:  general matrices
00429 *
00430          NTYPES = 11
00431          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00432 *
00433          IF( TSTCHK ) THEN
00434             CALL ZCHKGE( DOTYPE, NM, MVAL, NN, NVAL, NNB2, NBVAL2, NNS,
00435      $                   NSVAL, THRESH, TSTERR, LDA, A( 1, 1 ),
00436      $                   A( 1, 2 ), A( 1, 3 ), B( 1, 1 ), B( 1, 2 ),
00437      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
00438          ELSE
00439             WRITE( NOUT, FMT = 9989 )PATH
00440          END IF
00441 *
00442          IF( TSTDRV ) THEN
00443             CALL ZDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00444      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00445      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
00446      $                   RWORK, IWORK, NOUT )
00447          ELSE
00448             WRITE( NOUT, FMT = 9988 )PATH
00449          END IF
00450 *
00451       ELSE IF( LSAMEN( 2, C2, 'GB' ) ) THEN
00452 *
00453 *        GB:  general banded matrices
00454 *
00455          LA = ( 2*KDMAX+1 )*NMAX
00456          LAFAC = ( 3*KDMAX+1 )*NMAX
00457          NTYPES = 8
00458          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00459 *
00460          IF( TSTCHK ) THEN
00461             CALL ZCHKGB( DOTYPE, NM, MVAL, NN, NVAL, NNB2, NBVAL2, NNS,
00462      $                   NSVAL, THRESH, TSTERR, A( 1, 1 ), LA,
00463      $                   A( 1, 3 ), LAFAC, B( 1, 1 ), B( 1, 2 ),
00464      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
00465          ELSE
00466             WRITE( NOUT, FMT = 9989 )PATH
00467          END IF
00468 *
00469          IF( TSTDRV ) THEN
00470             CALL ZDRVGB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
00471      $                   A( 1, 1 ), LA, A( 1, 3 ), LAFAC, A( 1, 6 ),
00472      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S,
00473      $                   WORK, RWORK, IWORK, NOUT )
00474          ELSE
00475             WRITE( NOUT, FMT = 9988 )PATH
00476          END IF
00477 *
00478       ELSE IF( LSAMEN( 2, C2, 'GT' ) ) THEN
00479 *
00480 *        GT:  general tridiagonal matrices
00481 *
00482          NTYPES = 12
00483          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00484 *
00485          IF( TSTCHK ) THEN
00486             CALL ZCHKGT( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00487      $                   A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
00488      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
00489          ELSE
00490             WRITE( NOUT, FMT = 9989 )PATH
00491          END IF
00492 *
00493          IF( TSTDRV ) THEN
00494             CALL ZDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
00495      $                   A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
00496      $                   B( 1, 3 ), WORK, RWORK, IWORK, NOUT )
00497          ELSE
00498             WRITE( NOUT, FMT = 9988 )PATH
00499          END IF
00500 *
00501       ELSE IF( LSAMEN( 2, C2, 'PO' ) ) THEN
00502 *
00503 *        PO:  positive definite matrices
00504 *
00505          NTYPES = 9
00506          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00507 *
00508          IF( TSTCHK ) THEN
00509             CALL ZCHKPO( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
00510      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
00511      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
00512      $                   WORK, RWORK, NOUT )
00513          ELSE
00514             WRITE( NOUT, FMT = 9989 )PATH
00515          END IF
00516 *
00517          IF( TSTDRV ) THEN
00518             CALL ZDRVPO( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00519      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00520      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
00521      $                   RWORK, NOUT )
00522          ELSE
00523             WRITE( NOUT, FMT = 9988 )PATH
00524          END IF
00525 *
00526       ELSE IF( LSAMEN( 2, C2, 'PS' ) ) THEN
00527 *
00528 *        PS:  positive semi-definite matrices
00529 *
00530          NTYPES = 9
00531 *
00532          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00533 *
00534          IF( TSTCHK ) THEN
00535             CALL ZCHKPS( DOTYPE, NN, NVAL, NNB2, NBVAL2, NRANK,
00536      $                   RANKVAL, THRESH, TSTERR, LDA, A( 1, 1 ),
00537      $                   A( 1, 2 ), A( 1, 3 ), PIV, WORK, RWORK,
00538      $                   NOUT )
00539          ELSE
00540             WRITE( NOUT, FMT = 9989 )PATH
00541          END IF
00542 *
00543       ELSE IF( LSAMEN( 2, C2, 'PP' ) ) THEN
00544 *
00545 *        PP:  positive definite packed matrices
00546 *
00547          NTYPES = 9
00548          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00549 *
00550          IF( TSTCHK ) THEN
00551             CALL ZCHKPP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00552      $                   LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
00553      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
00554      $                   NOUT )
00555          ELSE
00556             WRITE( NOUT, FMT = 9989 )PATH
00557          END IF
00558 *
00559          IF( TSTDRV ) THEN
00560             CALL ZDRVPP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00561      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00562      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
00563      $                   RWORK, NOUT )
00564          ELSE
00565             WRITE( NOUT, FMT = 9988 )PATH
00566          END IF
00567 *
00568       ELSE IF( LSAMEN( 2, C2, 'PB' ) ) THEN
00569 *
00570 *        PB:  positive definite banded matrices
00571 *
00572          NTYPES = 8
00573          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00574 *
00575          IF( TSTCHK ) THEN
00576             CALL ZCHKPB( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
00577      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
00578      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
00579      $                   WORK, RWORK, NOUT )
00580          ELSE
00581             WRITE( NOUT, FMT = 9989 )PATH
00582          END IF
00583 *
00584          IF( TSTDRV ) THEN
00585             CALL ZDRVPB( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00586      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00587      $                   B( 1, 2 ), B( 1, 3 ), B( 1, 4 ), S, WORK,
00588      $                   RWORK, NOUT )
00589          ELSE
00590             WRITE( NOUT, FMT = 9988 )PATH
00591          END IF
00592 *
00593       ELSE IF( LSAMEN( 2, C2, 'PT' ) ) THEN
00594 *
00595 *        PT:  positive definite tridiagonal matrices
00596 *
00597          NTYPES = 12
00598          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00599 *
00600          IF( TSTCHK ) THEN
00601             CALL ZCHKPT( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00602      $                   A( 1, 1 ), S, A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
00603      $                   B( 1, 3 ), WORK, RWORK, NOUT )
00604          ELSE
00605             WRITE( NOUT, FMT = 9989 )PATH
00606          END IF
00607 *
00608          IF( TSTDRV ) THEN
00609             CALL ZDRVPT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
00610      $                   A( 1, 1 ), S, A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
00611      $                   B( 1, 3 ), WORK, RWORK, NOUT )
00612          ELSE
00613             WRITE( NOUT, FMT = 9988 )PATH
00614          END IF
00615 *
00616       ELSE IF( LSAMEN( 2, C2, 'HE' ) ) THEN
00617 *
00618 *        HE:  Hermitian indefinite matrices
00619 *
00620          NTYPES = 10
00621          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00622 *
00623          IF( TSTCHK ) THEN
00624             CALL ZCHKHE( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
00625      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
00626      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
00627      $                   WORK, RWORK, IWORK, NOUT )
00628          ELSE
00629             WRITE( NOUT, FMT = 9989 )PATH
00630          END IF
00631 *
00632          IF( TSTDRV ) THEN
00633             CALL ZDRVHE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00634      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00635      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
00636      $                   NOUT )
00637          ELSE
00638             WRITE( NOUT, FMT = 9988 )PATH
00639          END IF
00640 *
00641       ELSE IF( LSAMEN( 2, C2, 'HP' ) ) THEN
00642 *
00643 *        HP:  Hermitian indefinite packed matrices
00644 *
00645          NTYPES = 10
00646          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00647 *
00648          IF( TSTCHK ) THEN
00649             CALL ZCHKHP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00650      $                   LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
00651      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
00652      $                   IWORK, NOUT )
00653          ELSE
00654             WRITE( NOUT, FMT = 9989 )PATH
00655          END IF
00656 *
00657          IF( TSTDRV ) THEN
00658             CALL ZDRVHP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00659      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00660      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
00661      $                   NOUT )
00662          ELSE
00663             WRITE( NOUT, FMT = 9988 )PATH
00664          END IF
00665 *
00666       ELSE IF( LSAMEN( 2, C2, 'SY' ) ) THEN
00667 *
00668 *        SY:  symmetric indefinite matrices,
00669 *             with partial (Bunch-Kaufman) pivoting algorithm
00670 *
00671          NTYPES = 11
00672          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00673 *
00674          IF( TSTCHK ) THEN
00675             CALL ZCHKSY( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
00676      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
00677      $                   A( 1, 3 ), B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
00678      $                   WORK, RWORK, IWORK, NOUT )
00679          ELSE
00680             WRITE( NOUT, FMT = 9989 )PATH
00681          END IF
00682 *
00683          IF( TSTDRV ) THEN
00684             CALL ZDRVSY( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00685      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00686      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
00687      $                   NOUT )
00688          ELSE
00689             WRITE( NOUT, FMT = 9988 )PATH
00690          END IF
00691 *
00692       ELSE IF( LSAMEN( 2, C2, 'SP' ) ) THEN
00693 *
00694 *        SP:  symmetric indefinite packed matrices,
00695 *             with partial (Bunch-Kaufman) pivoting algorithm
00696 *
00697          NTYPES = 11
00698          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00699 *
00700          IF( TSTCHK ) THEN
00701             CALL ZCHKSP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00702      $                   LDA, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
00703      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
00704      $                   IWORK, NOUT )
00705          ELSE
00706             WRITE( NOUT, FMT = 9989 )PATH
00707          END IF
00708 *
00709          IF( TSTDRV ) THEN
00710             CALL ZDRVSP( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, LDA,
00711      $                   A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), B( 1, 1 ),
00712      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, IWORK,
00713      $                   NOUT )
00714          ELSE
00715             WRITE( NOUT, FMT = 9988 )PATH
00716          END IF
00717 *
00718       ELSE IF( LSAMEN( 2, C2, 'TR' ) ) THEN
00719 *
00720 *        TR:  triangular matrices
00721 *
00722          NTYPES = 18
00723          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00724 *
00725          IF( TSTCHK ) THEN
00726             CALL ZCHKTR( DOTYPE, NN, NVAL, NNB2, NBVAL2, NNS, NSVAL,
00727      $                   THRESH, TSTERR, LDA, A( 1, 1 ), A( 1, 2 ),
00728      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), WORK, RWORK,
00729      $                   NOUT )
00730          ELSE
00731             WRITE( NOUT, FMT = 9989 )PATH
00732          END IF
00733 *
00734       ELSE IF( LSAMEN( 2, C2, 'TP' ) ) THEN
00735 *
00736 *        TP:  triangular packed matrices
00737 *
00738          NTYPES = 18
00739          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00740 *
00741          IF( TSTCHK ) THEN
00742             CALL ZCHKTP( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00743      $                   LDA, A( 1, 1 ), A( 1, 2 ), B( 1, 1 ),
00744      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, NOUT )
00745          ELSE
00746             WRITE( NOUT, FMT = 9989 )PATH
00747          END IF
00748 *
00749       ELSE IF( LSAMEN( 2, C2, 'TB' ) ) THEN
00750 *
00751 *        TB:  triangular banded matrices
00752 *
00753          NTYPES = 17
00754          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00755 *
00756          IF( TSTCHK ) THEN
00757             CALL ZCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00758      $                   LDA, A( 1, 1 ), A( 1, 2 ), B( 1, 1 ),
00759      $                   B( 1, 2 ), B( 1, 3 ), WORK, RWORK, NOUT )
00760          ELSE
00761             WRITE( NOUT, FMT = 9989 )PATH
00762          END IF
00763 *
00764       ELSE IF( LSAMEN( 2, C2, 'QR' ) ) THEN
00765 *
00766 *        QR:  QR factorization
00767 *
00768          NTYPES = 8
00769          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00770 *
00771          IF( TSTCHK ) THEN
00772             CALL ZCHKQR( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
00773      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
00774      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
00775      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
00776      $                   WORK, RWORK, IWORK, NOUT )
00777          ELSE
00778             WRITE( NOUT, FMT = 9989 )PATH
00779          END IF
00780 *
00781       ELSE IF( LSAMEN( 2, C2, 'LQ' ) ) THEN
00782 *
00783 *        LQ:  LQ factorization
00784 *
00785          NTYPES = 8
00786          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00787 *
00788          IF( TSTCHK ) THEN
00789             CALL ZCHKLQ( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
00790      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
00791      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
00792      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
00793      $                   WORK, RWORK, NOUT )
00794          ELSE
00795             WRITE( NOUT, FMT = 9989 )PATH
00796          END IF
00797 *
00798       ELSE IF( LSAMEN( 2, C2, 'QL' ) ) THEN
00799 *
00800 *        QL:  QL factorization
00801 *
00802          NTYPES = 8
00803          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00804 *
00805          IF( TSTCHK ) THEN
00806             CALL ZCHKQL( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
00807      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
00808      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
00809      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
00810      $                   WORK, RWORK, NOUT )
00811          ELSE
00812             WRITE( NOUT, FMT = 9989 )PATH
00813          END IF
00814 *
00815       ELSE IF( LSAMEN( 2, C2, 'RQ' ) ) THEN
00816 *
00817 *        RQ:  RQ factorization
00818 *
00819          NTYPES = 8
00820          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00821 *
00822          IF( TSTCHK ) THEN
00823             CALL ZCHKRQ( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
00824      $                   NRHS, THRESH, TSTERR, NMAX, A( 1, 1 ),
00825      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
00826      $                   B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), B( 1, 4 ),
00827      $                   WORK, RWORK, IWORK, NOUT )
00828          ELSE
00829             WRITE( NOUT, FMT = 9989 )PATH
00830          END IF
00831 *
00832       ELSE IF( LSAMEN( 2, C2, 'EQ' ) ) THEN
00833 *
00834 *        EQ:  Equilibration routines for general and positive definite
00835 *             matrices (THREQ should be between 2 and 10)
00836 *
00837          IF( TSTCHK ) THEN
00838             CALL ZCHKEQ( THREQ, NOUT )
00839          ELSE
00840             WRITE( NOUT, FMT = 9989 )PATH
00841          END IF
00842 *
00843       ELSE IF( LSAMEN( 2, C2, 'TZ' ) ) THEN
00844 *
00845 *        TZ:  Trapezoidal matrix
00846 *
00847          NTYPES = 3
00848          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00849 *
00850          IF( TSTCHK ) THEN
00851             CALL ZCHKTZ( DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR,
00852      $                   A( 1, 1 ), A( 1, 2 ), S( 1 ),
00853      $                   B( 1, 1 ), WORK, RWORK, NOUT )
00854          ELSE
00855             WRITE( NOUT, FMT = 9989 )PATH
00856          END IF
00857 *
00858       ELSE IF( LSAMEN( 2, C2, 'QP' ) ) THEN
00859 *
00860 *        QP:  QR factorization with pivoting
00861 *
00862          NTYPES = 6
00863          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00864 *
00865          IF( TSTCHK ) THEN
00866             CALL ZCHKQP( DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR,
00867      $                   A( 1, 1 ), A( 1, 2 ), S( 1 ),
00868      $                   B( 1, 1 ), WORK, RWORK, IWORK, NOUT )
00869             CALL ZCHKQ3( DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL,
00870      $                   THRESH, A( 1, 1 ), A( 1, 2 ), S( 1 ),
00871      $                   B( 1, 1 ), WORK, RWORK, IWORK,
00872      $                   NOUT )
00873          ELSE
00874             WRITE( NOUT, FMT = 9989 )PATH
00875          END IF
00876 *
00877       ELSE IF( LSAMEN( 2, C2, 'LS' ) ) THEN
00878 *
00879 *        LS:  Least squares drivers
00880 *
00881          NTYPES = 6
00882          CALL ALAREQ( PATH, NMATS, DOTYPE, NTYPES, NIN, NOUT )
00883 *
00884          IF( TSTDRV ) THEN
00885             CALL ZDRVLS( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
00886      $                   NBVAL, NXVAL, THRESH, TSTERR, A( 1, 1 ),
00887      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
00888      $                   S( 1 ), S( NMAX+1 ), WORK, RWORK, IWORK,
00889      $                   NOUT )
00890          ELSE
00891             WRITE( NOUT, FMT = 9989 )PATH
00892          END IF
00893 *
00894 *
00895       ELSE IF( LSAMEN( 2, C2, 'QT' ) ) THEN
00896 *
00897 *        QT:  QRT routines for general matrices
00898 *
00899          IF( TSTCHK ) THEN
00900             CALL ZCHKQRT( THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, 
00901      $                    NBVAL, NOUT )
00902          ELSE
00903             WRITE( NOUT, FMT = 9989 )PATH
00904          END IF
00905 *
00906       ELSE IF( LSAMEN( 2, C2, 'QX' ) ) THEN
00907 *
00908 *        QX:  QRT routines for triangular-pentagonal matrices
00909 *
00910          IF( TSTCHK ) THEN
00911             CALL ZCHKQRTP( THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, 
00912      $                     NBVAL, NOUT )
00913          ELSE
00914             WRITE( NOUT, FMT = 9989 )PATH
00915          END IF
00916 *
00917       ELSE
00918 *
00919          WRITE( NOUT, FMT = 9990 )PATH
00920       END IF
00921 *
00922 *     Go back to get another input line.
00923 *
00924       GO TO 80
00925 *
00926 *     Branch to this line when the last record is read.
00927 *
00928   140 CONTINUE
00929       CLOSE ( NIN )
00930       S2 = DSECND( )
00931       WRITE( NOUT, FMT = 9998 )
00932       WRITE( NOUT, FMT = 9997 )S2 - S1
00933 *
00934  9999 FORMAT( / ' Execution not attempted due to input errors' )
00935  9998 FORMAT( / ' End of tests' )
00936  9997 FORMAT( ' Total time used = ', F12.2, ' seconds', / )
00937  9996 FORMAT( ' Invalid input value: ', A4, '=', I6, '; must be >=',
00938      $      I6 )
00939  9995 FORMAT( ' Invalid input value: ', A4, '=', I6, '; must be <=',
00940      $      I6 )
00941  9994 FORMAT( ' Tests of the COMPLEX*16 LAPACK routines ',
00942      $      / ' LAPACK VERSION ', I1, '.', I1, '.', I1,
00943      $      / / ' The following parameter values will be used:' )
00944  9993 FORMAT( 4X, A4, ':  ', 10I6, / 11X, 10I6 )
00945  9992 FORMAT( / ' Routines pass computational tests if test ratio is ',
00946      $      'less than', F8.2, / )
00947  9991 FORMAT( ' Relative machine ', A, ' is taken to be', D16.6 )
00948  9990 FORMAT( / 1X, A3, ':  Unrecognized path name' )
00949  9989 FORMAT( / 1X, A3, ' routines were not tested' )
00950  9988 FORMAT( / 1X, A3, ' driver routines were not tested' )
00951 *
00952 *     End of ZCHKAA
00953 *
00954       END
 All Files Functions