LAPACK: TESTING/EIG/cchkee.f Source File

00001       PROGRAM CCHKEE
00002 *
00003 *  -- LAPACK test routine (version 3.1.1) --
00004 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
00005 *     February 2007
00006 *
00007 *  Purpose
00008 *  =======
00009 *
00010 *  CCHKEE tests the COMPLEX LAPACK subroutines for the matrix
00011 *  eigenvalue problem.  The test paths in this version are
00012 *
00013 *  NEP (Nonsymmetric Eigenvalue Problem):
00014 *      Test CGEHRD, CUNGHR, CHSEQR, CTREVC, CHSEIN, and CUNMHR
00015 *
00016 *  SEP (Hermitian Eigenvalue Problem):
00017 *      Test CHETRD, CUNGTR, CSTEQR, CSTERF, CSTEIN, CSTEDC,
00018 *      and drivers CHEEV(X), CHBEV(X), CHPEV(X),
00019 *                  CHEEVD,   CHBEVD,   CHPEVD
00020 *
00021 *  SVD (Singular Value Decomposition):
00022 *      Test CGEBRD, CUNGBR, and CBDSQR
00023 *      and the drivers CGESVD, CGESDD
00024 *
00025 *  CEV (Nonsymmetric Eigenvalue/eigenvector Driver):
00026 *      Test CGEEV
00027 *
00028 *  CES (Nonsymmetric Schur form Driver):
00029 *      Test CGEES
00030 *
00031 *  CVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver):
00032 *      Test CGEEVX
00033 *
00034 *  CSX (Nonsymmetric Schur form Expert Driver):
00035 *      Test CGEESX
00036 *
00037 *  CGG (Generalized Nonsymmetric Eigenvalue Problem):
00038 *      Test CGGHRD, CGGBAL, CGGBAK, CHGEQZ, and CTGEVC
00039 *      and the driver routines CGEGS and CGEGV
00040 *
00041 *  CGS (Generalized Nonsymmetric Schur form Driver):
00042 *      Test CGGES
00043 *
00044 *  CGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver):
00045 *      Test CGGEV
00046 *
00047 *  CGX (Generalized Nonsymmetric Schur form Expert Driver):
00048 *      Test CGGESX
00049 *
00050 *  CXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):
00051 *      Test CGGEVX
00052 *
00053 *  CSG (Hermitian Generalized Eigenvalue Problem):
00054 *      Test CHEGST, CHEGV, CHEGVD, CHEGVX, CHPGST, CHPGV, CHPGVD,
00055 *      CHPGVX, CHBGST, CHBGV, CHBGVD, and CHBGVX
00056 *
00057 *  CHB (Hermitian Band Eigenvalue Problem):
00058 *      Test CHBTRD
00059 *
00060 *  CBB (Band Singular Value Decomposition):
00061 *      Test CGBBRD
00062 *
00063 *  CEC (Eigencondition estimation):
00064 *      Test CTRSYL, CTREXC, CTRSNA, and CTRSEN
00065 *
00066 *  CBL (Balancing a general matrix)
00067 *      Test CGEBAL
00068 *
00069 *  CBK (Back transformation on a balanced matrix)
00070 *      Test CGEBAK
00071 *
00072 *  CGL (Balancing a matrix pair)
00073 *      Test CGGBAL
00074 *
00075 *  CGK (Back transformation on a matrix pair)
00076 *      Test CGGBAK
00077 *
00078 *  GLM (Generalized Linear Regression Model):
00079 *      Tests CGGGLM
00080 *
00081 *  GQR (Generalized QR and RQ factorizations):
00082 *      Tests CGGQRF and CGGRQF
00083 *
00084 *  GSV (Generalized Singular Value Decomposition):
00085 *      Tests CGGSVD, CGGSVP, CTGSJA, CLAGS2, CLAPLL, and CLAPMT
00086 *
00087 *  LSE (Constrained Linear Least Squares):
00088 *      Tests CGGLSE
00089 *
00090 *  Each test path has a different set of inputs, but the data sets for
00091 *  the driver routines xEV, xES, xVX, and xSX can be concatenated in a
00092 *  single input file.  The first line of input should contain one of the
00093 *  3-character path names in columns 1-3.  The number of remaining lines
00094 *  depends on what is found on the first line.
00095 *
00096 *  The number of matrix types used in testing is often controllable from
00097 *  the input file.  The number of matrix types for each path, and the
00098 *  test routine that describes them, is as follows:
00099 *
00100 *  Path name(s)  Types    Test routine
00101 *
00102 *  CHS or NEP      21     CCHKHS
00103 *  CST or SEP      21     CCHKST (routines)
00104 *                  18     CDRVST (drivers)
00105 *  CBD or SVD      16     CCHKBD (routines)
00106 *                   5     CDRVBD (drivers)
00107 *  CEV             21     CDRVEV
00108 *  CES             21     CDRVES
00109 *  CVX             21     CDRVVX
00110 *  CSX             21     CDRVSX
00111 *  CGG             26     CCHKGG (routines)
00112 *                  26     CDRVGG (drivers)
00113 *  CGS             26     CDRGES
00114 *  CGX              5     CDRGSX
00115 *  CGV             26     CDRGEV
00116 *  CXV              2     CDRGVX
00117 *  CSG             21     CDRVSG
00118 *  CHB             15     CCHKHB
00119 *  CBB             15     CCHKBB
00120 *  CEC              -     CCHKEC
00121 *  CBL              -     CCHKBL
00122 *  CBK              -     CCHKBK
00123 *  CGL              -     CCHKGL
00124 *  CGK              -     CCHKGK
00125 *  GLM              8     CCKGLM
00126 *  GQR              8     CCKGQR
00127 *  GSV              8     CCKGSV
00128 *  LSE              8     CCKLSE
00129 *
00130 *-----------------------------------------------------------------------
00131 *
00132 *  NEP input file:
00133 *
00134 *  line 2:  NN, INTEGER
00135 *           Number of values of N.
00136 *
00137 *  line 3:  NVAL, INTEGER array, dimension (NN)
00138 *           The values for the matrix dimension N.
00139 *
00140 *  line 4:  NPARMS, INTEGER
00141 *           Number of values of the parameters NB, NBMIN, NX, NS, and
00142 *           MAXB.
00143 *
00144 *  line 5:  NBVAL, INTEGER array, dimension (NPARMS)
00145 *           The values for the blocksize NB.
00146 *
00147 *  line 6:  NBMIN, INTEGER array, dimension (NPARMS)
00148 *           The values for the minimum blocksize NBMIN.
00149 *
00150 *  line 7:  NXVAL, INTEGER array, dimension (NPARMS)
00151 *           The values for the crossover point NX.
00152 *
00153 *  line 8:  INMIN, INTEGER array, dimension (NPARMS)
00154 *           LAHQR vs TTQRE crossover point, >= 11
00155 *
00156 *  line 9:  INWIN, INTEGER array, dimension (NPARMS)
00157 *           recommended deflation window size
00158 *
00159 *  line 10: INIBL, INTEGER array, dimension (NPARMS)
00160 *           nibble crossover point
00161 *
00162 *  line 11:  ISHFTS, INTEGER array, dimension (NPARMS)
00163 *           number of simultaneous shifts)
00164 *
00165 *  line 12:  IACC22, INTEGER array, dimension (NPARMS)
00166 *           select structured matrix multiply: 0, 1 or 2)
00167 *
00168 *  line 13: THRESH
00169 *           Threshold value for the test ratios.  Information will be
00170 *           printed about each test for which the test ratio is greater
00171 *           than or equal to the threshold.  To have all of the test
00172 *           ratios printed, use THRESH = 0.0 .
00173 *
00174 *  line 14: NEWSD, INTEGER
00175 *           A code indicating how to set the random number seed.
00176 *           = 0:  Set the seed to a default value before each run
00177 *           = 1:  Initialize the seed to a default value only before the
00178 *                 first run
00179 *           = 2:  Like 1, but use the seed values on the next line
00180 *
00181 *  If line 14 was 2:
00182 *
00183 *  line 15: INTEGER array, dimension (4)
00184 *           Four integer values for the random number seed.
00185 *
00186 *  lines 15-EOF:  The remaining lines occur in sets of 1 or 2 and allow
00187 *           the user to specify the matrix types.  Each line contains
00188 *           a 3-character path name in columns 1-3, and the number
00189 *           of matrix types must be the first nonblank item in columns
00190 *           4-80.  If the number of matrix types is at least 1 but is
00191 *           less than the maximum number of possible types, a second
00192 *           line will be read to get the numbers of the matrix types to
00193 *           be used.  For example,
00194 *  NEP 21
00195 *           requests all of the matrix types for the nonsymmetric
00196 *           eigenvalue problem, while
00197 *  NEP  4
00198 *  9 10 11 12
00199 *           requests only matrices of type 9, 10, 11, and 12.
00200 *
00201 *           The valid 3-character path names are 'NEP' or 'CHS' for the
00202 *           nonsymmetric eigenvalue routines.
00203 *
00204 *-----------------------------------------------------------------------
00205 *
00206 *  SEP or CSG input file:
00207 *
00208 *  line 2:  NN, INTEGER
00209 *           Number of values of N.
00210 *
00211 *  line 3:  NVAL, INTEGER array, dimension (NN)
00212 *           The values for the matrix dimension N.
00213 *
00214 *  line 4:  NPARMS, INTEGER
00215 *           Number of values of the parameters NB, NBMIN, and NX.
00216 *
00217 *  line 5:  NBVAL, INTEGER array, dimension (NPARMS)
00218 *           The values for the blocksize NB.
00219 *
00220 *  line 6:  NBMIN, INTEGER array, dimension (NPARMS)
00221 *           The values for the minimum blocksize NBMIN.
00222 *
00223 *  line 7:  NXVAL, INTEGER array, dimension (NPARMS)
00224 *           The values for the crossover point NX.
00225 *
00226 *  line 8:  THRESH
00227 *           Threshold value for the test ratios.  Information will be
00228 *           printed about each test for which the test ratio is greater
00229 *           than or equal to the threshold.
00230 *
00231 *  line 9:  TSTCHK, LOGICAL
00232 *           Flag indicating whether or not to test the LAPACK routines.
00233 *
00234 *  line 10: TSTDRV, LOGICAL
00235 *           Flag indicating whether or not to test the driver routines.
00236 *
00237 *  line 11: TSTERR, LOGICAL
00238 *           Flag indicating whether or not to test the error exits for
00239 *           the LAPACK routines and driver routines.
00240 *
00241 *  line 12: NEWSD, INTEGER
00242 *           A code indicating how to set the random number seed.
00243 *           = 0:  Set the seed to a default value before each run
00244 *           = 1:  Initialize the seed to a default value only before the
00245 *                 first run
00246 *           = 2:  Like 1, but use the seed values on the next line
00247 *
00248 *  If line 12 was 2:
00249 *
00250 *  line 13: INTEGER array, dimension (4)
00251 *           Four integer values for the random number seed.
00252 *
00253 *  lines 13-EOF:  Lines specifying matrix types, as for NEP.
00254 *           The valid 3-character path names are 'SEP' or 'CST' for the
00255 *           Hermitian eigenvalue routines and driver routines, and
00256 *           'CSG' for the routines for the Hermitian generalized
00257 *           eigenvalue problem.
00258 *
00259 *-----------------------------------------------------------------------
00260 *
00261 *  SVD input file:
00262 *
00263 *  line 2:  NN, INTEGER
00264 *           Number of values of M and N.
00265 *
00266 *  line 3:  MVAL, INTEGER array, dimension (NN)
00267 *           The values for the matrix row dimension M.
00268 *
00269 *  line 4:  NVAL, INTEGER array, dimension (NN)
00270 *           The values for the matrix column dimension N.
00271 *
00272 *  line 5:  NPARMS, INTEGER
00273 *           Number of values of the parameter NB, NBMIN, NX, and NRHS.
00274 *
00275 *  line 6:  NBVAL, INTEGER array, dimension (NPARMS)
00276 *           The values for the blocksize NB.
00277 *
00278 *  line 7:  NBMIN, INTEGER array, dimension (NPARMS)
00279 *           The values for the minimum blocksize NBMIN.
00280 *
00281 *  line 8:  NXVAL, INTEGER array, dimension (NPARMS)
00282 *           The values for the crossover point NX.
00283 *
00284 *  line 9:  NSVAL, INTEGER array, dimension (NPARMS)
00285 *           The values for the number of right hand sides NRHS.
00286 *
00287 *  line 10: THRESH
00288 *           Threshold value for the test ratios.  Information will be
00289 *           printed about each test for which the test ratio is greater
00290 *           than or equal to the threshold.
00291 *
00292 *  line 11: TSTCHK, LOGICAL
00293 *           Flag indicating whether or not to test the LAPACK routines.
00294 *
00295 *  line 12: TSTDRV, LOGICAL
00296 *           Flag indicating whether or not to test the driver routines.
00297 *
00298 *  line 13: TSTERR, LOGICAL
00299 *           Flag indicating whether or not to test the error exits for
00300 *           the LAPACK routines and driver routines.
00301 *
00302 *  line 14: NEWSD, INTEGER
00303 *           A code indicating how to set the random number seed.
00304 *           = 0:  Set the seed to a default value before each run
00305 *           = 1:  Initialize the seed to a default value only before the
00306 *                 first run
00307 *           = 2:  Like 1, but use the seed values on the next line
00308 *
00309 *  If line 14 was 2:
00310 *
00311 *  line 15: INTEGER array, dimension (4)
00312 *           Four integer values for the random number seed.
00313 *
00314 *  lines 15-EOF:  Lines specifying matrix types, as for NEP.
00315 *           The 3-character path names are 'SVD' or 'CBD' for both the
00316 *           SVD routines and the SVD driver routines.
00317 *
00318 *-----------------------------------------------------------------------
00319 *
00320 *  CEV and CES data files:
00321 *
00322 *  line 1:  'CEV' or 'CES' in columns 1 to 3.
00323 *
00324 *  line 2:  NSIZES, INTEGER
00325 *           Number of sizes of matrices to use. Should be at least 0
00326 *           and at most 20. If NSIZES = 0, no testing is done
00327 *           (although the remaining  3 lines are still read).
00328 *
00329 *  line 3:  NN, INTEGER array, dimension(NSIZES)
00330 *           Dimensions of matrices to be tested.
00331 *
00332 *  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
00333 *           These integer parameters determine how blocking is done
00334 *           (see ILAENV for details)
00335 *           NB     : block size
00336 *           NBMIN  : minimum block size
00337 *           NX     : minimum dimension for blocking
00338 *           NS     : number of shifts in xHSEQR
00339 *           NBCOL  : minimum column dimension for blocking
00340 *
00341 *  line 5:  THRESH, REAL
00342 *           The test threshold against which computed residuals are
00343 *           compared. Should generally be in the range from 10. to 20.
00344 *           If it is 0., all test case data will be printed.
00345 *
00346 *  line 6:  NEWSD, INTEGER
00347 *           A code indicating how to set the random number seed.
00348 *           = 0:  Set the seed to a default value before each run
00349 *           = 1:  Initialize the seed to a default value only before the
00350 *                 first run
00351 *           = 2:  Like 1, but use the seed values on the next line
00352 *
00353 *  If line 6 was 2:
00354 *
00355 *  line 7:  INTEGER array, dimension (4)
00356 *           Four integer values for the random number seed.
00357 *
00358 *  lines 8 and following:  Lines specifying matrix types, as for NEP.
00359 *           The 3-character path name is 'CEV' to test CGEEV, or
00360 *           'CES' to test CGEES.
00361 *
00362 *-----------------------------------------------------------------------
00363 *
00364 *  The CVX data has two parts. The first part is identical to CEV,
00365 *  and the second part consists of test matrices with precomputed
00366 *  solutions.
00367 *
00368 *  line 1:  'CVX' in columns 1-3.
00369 *
00370 *  line 2:  NSIZES, INTEGER
00371 *           If NSIZES = 0, no testing of randomly generated examples
00372 *           is done, but any precomputed examples are tested.
00373 *
00374 *  line 3:  NN, INTEGER array, dimension(NSIZES)
00375 *
00376 *  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
00377 *
00378 *  line 5:  THRESH, REAL
00379 *
00380 *  line 6:  NEWSD, INTEGER
00381 *
00382 *  If line 6 was 2:
00383 *
00384 *  line 7:  INTEGER array, dimension (4)
00385 *
00386 *  lines 8 and following: The first line contains 'CVX' in columns 1-3
00387 *           followed by the number of matrix types, possibly with
00388 *           a second line to specify certain matrix types.
00389 *           If the number of matrix types = 0, no testing of randomly
00390 *           generated examples is done, but any precomputed examples
00391 *           are tested.
00392 *
00393 *  remaining lines : Each matrix is stored on 1+N+N**2 lines, where N is
00394 *           its dimension. The first line contains the dimension N and
00395 *           ISRT (two integers). ISRT indicates whether the last N lines
00396 *           are sorted by increasing real part of the eigenvalue
00397 *           (ISRT=0) or by increasing imaginary part (ISRT=1). The next
00398 *           N**2 lines contain the matrix rowwise, one entry per line.
00399 *           The last N lines correspond to each eigenvalue. Each of
00400 *           these last N lines contains 4 real values: the real part of
00401 *           the eigenvalues, the imaginary part of the eigenvalue, the
00402 *           reciprocal condition number of the eigenvalues, and the
00403 *           reciprocal condition number of the vector eigenvector. The
00404 *           end of data is indicated by dimension N=0. Even if no data
00405 *           is to be tested, there must be at least one line containing
00406 *           N=0.
00407 *
00408 *-----------------------------------------------------------------------
00409 *
00410 *  The CSX data is like CVX. The first part is identical to CEV, and the
00411 *  second part consists of test matrices with precomputed solutions.
00412 *
00413 *  line 1:  'CSX' in columns 1-3.
00414 *
00415 *  line 2:  NSIZES, INTEGER
00416 *           If NSIZES = 0, no testing of randomly generated examples
00417 *           is done, but any precomputed examples are tested.
00418 *
00419 *  line 3:  NN, INTEGER array, dimension(NSIZES)
00420 *
00421 *  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
00422 *
00423 *  line 5:  THRESH, REAL
00424 *
00425 *  line 6:  NEWSD, INTEGER
00426 *
00427 *  If line 6 was 2:
00428 *
00429 *  line 7:  INTEGER array, dimension (4)
00430 *
00431 *  lines 8 and following: The first line contains 'CSX' in columns 1-3
00432 *           followed by the number of matrix types, possibly with
00433 *           a second line to specify certain matrix types.
00434 *           If the number of matrix types = 0, no testing of randomly
00435 *           generated examples is done, but any precomputed examples
00436 *           are tested.
00437 *
00438 *  remaining lines : Each matrix is stored on 3+N**2 lines, where N is
00439 *           its dimension. The first line contains the dimension N, the
00440 *           dimension M of an invariant subspace, and ISRT. The second
00441 *           line contains M integers, identifying the eigenvalues in the
00442 *           invariant subspace (by their position in a list of
00443 *           eigenvalues ordered by increasing real part (if ISRT=0) or
00444 *           by increasing imaginary part (if ISRT=1)). The next N**2
00445 *           lines contain the matrix rowwise. The last line contains the
00446 *           reciprocal condition number for the average of the selected
00447 *           eigenvalues, and the reciprocal condition number for the
00448 *           corresponding right invariant subspace. The end of data in
00449 *           indicated by a line containing N=0, M=0, and ISRT = 0.  Even
00450 *           if no data is to be tested, there must be at least one line
00451 *           containing N=0, M=0 and ISRT=0.
00452 *
00453 *-----------------------------------------------------------------------
00454 *
00455 *  CGG input file:
00456 *
00457 *  line 2:  NN, INTEGER
00458 *           Number of values of N.
00459 *
00460 *  line 3:  NVAL, INTEGER array, dimension (NN)
00461 *           The values for the matrix dimension N.
00462 *
00463 *  line 4:  NPARMS, INTEGER
00464 *           Number of values of the parameters NB, NBMIN, NBCOL, NS, and
00465 *           MAXB.
00466 *
00467 *  line 5:  NBVAL, INTEGER array, dimension (NPARMS)
00468 *           The values for the blocksize NB.
00469 *
00470 *  line 6:  NBMIN, INTEGER array, dimension (NPARMS)
00471 *           The values for NBMIN, the minimum row dimension for blocks.
00472 *
00473 *  line 7:  NSVAL, INTEGER array, dimension (NPARMS)
00474 *           The values for the number of shifts.
00475 *
00476 *  line 8:  MXBVAL, INTEGER array, dimension (NPARMS)
00477 *           The values for MAXB, used in determining minimum blocksize.
00478 *
00479 *  line 9:  NBCOL, INTEGER array, dimension (NPARMS)
00480 *           The values for NBCOL, the minimum column dimension for
00481 *           blocks.
00482 *
00483 *  line 10: THRESH
00484 *           Threshold value for the test ratios.  Information will be
00485 *           printed about each test for which the test ratio is greater
00486 *           than or equal to the threshold.
00487 *
00488 *  line 11: TSTCHK, LOGICAL
00489 *           Flag indicating whether or not to test the LAPACK routines.
00490 *
00491 *  line 12: TSTDRV, LOGICAL
00492 *           Flag indicating whether or not to test the driver routines.
00493 *
00494 *  line 13: TSTERR, LOGICAL
00495 *           Flag indicating whether or not to test the error exits for
00496 *           the LAPACK routines and driver routines.
00497 *
00498 *  line 14: NEWSD, INTEGER
00499 *           A code indicating how to set the random number seed.
00500 *           = 0:  Set the seed to a default value before each run
00501 *           = 1:  Initialize the seed to a default value only before the
00502 *                 first run
00503 *           = 2:  Like 1, but use the seed values on the next line
00504 *
00505 *  If line 14 was 2:
00506 *
00507 *  line 15: INTEGER array, dimension (4)
00508 *           Four integer values for the random number seed.
00509 *
00510 *  lines 16-EOF:  Lines specifying matrix types, as for NEP.
00511 *           The 3-character path name is 'CGG' for the generalized
00512 *           eigenvalue problem routines and driver routines.
00513 *
00514 *-----------------------------------------------------------------------
00515 *
00516 *  CGS and CGV input files:
00517 *
00518 *  line 1:  'CGS' or 'CGV' in columns 1 to 3.
00519 *
00520 *  line 2:  NN, INTEGER
00521 *           Number of values of N.
00522 *
00523 *  line 3:  NVAL, INTEGER array, dimension(NN)
00524 *           Dimensions of matrices to be tested.
00525 *
00526 *  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
00527 *           These integer parameters determine how blocking is done
00528 *           (see ILAENV for details)
00529 *           NB     : block size
00530 *           NBMIN  : minimum block size
00531 *           NX     : minimum dimension for blocking
00532 *           NS     : number of shifts in xHGEQR
00533 *           NBCOL  : minimum column dimension for blocking
00534 *
00535 *  line 5:  THRESH, REAL
00536 *           The test threshold against which computed residuals are
00537 *           compared. Should generally be in the range from 10. to 20.
00538 *           If it is 0., all test case data will be printed.
00539 *
00540 *  line 6:  TSTERR, LOGICAL
00541 *           Flag indicating whether or not to test the error exits.
00542 *
00543 *  line 7:  NEWSD, INTEGER
00544 *           A code indicating how to set the random number seed.
00545 *           = 0:  Set the seed to a default value before each run
00546 *           = 1:  Initialize the seed to a default value only before the
00547 *                 first run
00548 *           = 2:  Like 1, but use the seed values on the next line
00549 *
00550 *  If line 17 was 2:
00551 *
00552 *  line 7:  INTEGER array, dimension (4)
00553 *           Four integer values for the random number seed.
00554 *
00555 *  lines 7-EOF:  Lines specifying matrix types, as for NEP.
00556 *           The 3-character path name is 'CGS' for the generalized
00557 *           eigenvalue problem routines and driver routines.
00558 *
00559 *-----------------------------------------------------------------------
00560 *
00561 *  CGX input file:
00562 *  line 1:  'CGX' in columns 1 to 3.
00563 *
00564 *  line 2:  N, INTEGER
00565 *           Value of N.
00566 *
00567 *  line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
00568 *           These integer parameters determine how blocking is done
00569 *           (see ILAENV for details)
00570 *           NB     : block size
00571 *           NBMIN  : minimum block size
00572 *           NX     : minimum dimension for blocking
00573 *           NS     : number of shifts in xHGEQR
00574 *           NBCOL  : minimum column dimension for blocking
00575 *
00576 *  line 4:  THRESH, REAL
00577 *           The test threshold against which computed residuals are
00578 *           compared. Should generally be in the range from 10. to 20.
00579 *           Information will be printed about each test for which the
00580 *           test ratio is greater than or equal to the threshold.
00581 *
00582 *  line 5:  TSTERR, LOGICAL
00583 *           Flag indicating whether or not to test the error exits for
00584 *           the LAPACK routines and driver routines.
00585 *
00586 *  line 6:  NEWSD, INTEGER
00587 *           A code indicating how to set the random number seed.
00588 *           = 0:  Set the seed to a default value before each run
00589 *           = 1:  Initialize the seed to a default value only before the
00590 *                 first run
00591 *           = 2:  Like 1, but use the seed values on the next line
00592 *
00593 *  If line 6 was 2:
00594 *
00595 *  line 7: INTEGER array, dimension (4)
00596 *           Four integer values for the random number seed.
00597 *
00598 *  If line 2 was 0:
00599 *
00600 *  line 7-EOF: Precomputed examples are tested.
00601 *
00602 *  remaining lines : Each example is stored on 3+2*N*N lines, where N is
00603 *           its dimension. The first line contains the dimension (a
00604 *           single integer).  The next line contains an integer k such
00605 *           that only the last k eigenvalues will be selected and appear
00606 *           in the leading diagonal blocks of $A$ and $B$. The next N*N
00607 *           lines contain the matrix A, one element per line. The next N*N
00608 *           lines contain the matrix B. The last line contains the
00609 *           reciprocal of the eigenvalue cluster condition number and the
00610 *           reciprocal of the deflating subspace (associated with the
00611 *           selected eigencluster) condition number.  The end of data is
00612 *           indicated by dimension N=0.  Even if no data is to be tested,
00613 *           there must be at least one line containing N=0.
00614 *
00615 *-----------------------------------------------------------------------
00616 *
00617 *  CXV input files:
00618 *  line 1:  'CXV' in columns 1 to 3.
00619 *
00620 *  line 2:  N, INTEGER
00621 *           Value of N.
00622 *
00623 *  line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
00624 *           These integer parameters determine how blocking is done
00625 *           (see ILAENV for details)
00626 *           NB     : block size
00627 *           NBMIN  : minimum block size
00628 *           NX     : minimum dimension for blocking
00629 *           NS     : number of shifts in xHGEQR
00630 *           NBCOL  : minimum column dimension for blocking
00631 *
00632 *  line 4:  THRESH, REAL
00633 *           The test threshold against which computed residuals are
00634 *           compared. Should generally be in the range from 10. to 20.
00635 *           Information will be printed about each test for which the
00636 *           test ratio is greater than or equal to the threshold.
00637 *
00638 *  line 5:  TSTERR, LOGICAL
00639 *           Flag indicating whether or not to test the error exits for
00640 *           the LAPACK routines and driver routines.
00641 *
00642 *  line 6:  NEWSD, INTEGER
00643 *           A code indicating how to set the random number seed.
00644 *           = 0:  Set the seed to a default value before each run
00645 *           = 1:  Initialize the seed to a default value only before the
00646 *                 first run
00647 *           = 2:  Like 1, but use the seed values on the next line
00648 *
00649 *  If line 6 was 2:
00650 *
00651 *  line 7: INTEGER array, dimension (4)
00652 *           Four integer values for the random number seed.
00653 *
00654 *  If line 2 was 0:
00655 *
00656 *  line 7-EOF: Precomputed examples are tested.
00657 *
00658 *  remaining lines : Each example is stored on 3+2*N*N lines, where N is
00659 *           its dimension. The first line contains the dimension (a
00660 *           single integer). The next N*N lines contain the matrix A, one
00661 *           element per line. The next N*N lines contain the matrix B.
00662 *           The next line contains the reciprocals of the eigenvalue
00663 *           condition numbers.  The last line contains the reciprocals of
00664 *           the eigenvector condition numbers.  The end of data is
00665 *           indicated by dimension N=0.  Even if no data is to be tested,
00666 *           there must be at least one line containing N=0.
00667 *
00668 *-----------------------------------------------------------------------
00669 *
00670 *  CHB input file:
00671 *
00672 *  line 2:  NN, INTEGER
00673 *           Number of values of N.
00674 *
00675 *  line 3:  NVAL, INTEGER array, dimension (NN)
00676 *           The values for the matrix dimension N.
00677 *
00678 *  line 4:  NK, INTEGER
00679 *           Number of values of K.
00680 *
00681 *  line 5:  KVAL, INTEGER array, dimension (NK)
00682 *           The values for the matrix dimension K.
00683 *
00684 *  line 6:  THRESH
00685 *           Threshold value for the test ratios.  Information will be
00686 *           printed about each test for which the test ratio is greater
00687 *           than or equal to the threshold.
00688 *
00689 *  line 7:  NEWSD, INTEGER
00690 *           A code indicating how to set the random number seed.
00691 *           = 0:  Set the seed to a default value before each run
00692 *           = 1:  Initialize the seed to a default value only before the
00693 *                 first run
00694 *           = 2:  Like 1, but use the seed values on the next line
00695 *
00696 *  If line 7 was 2:
00697 *
00698 *  line 8:  INTEGER array, dimension (4)
00699 *           Four integer values for the random number seed.
00700 *
00701 *  lines 8-EOF:  Lines specifying matrix types, as for NEP.
00702 *           The 3-character path name is 'CHB'.
00703 *
00704 *-----------------------------------------------------------------------
00705 *
00706 *  CBB input file:
00707 *
00708 *  line 2:  NN, INTEGER
00709 *           Number of values of M and N.
00710 *
00711 *  line 3:  MVAL, INTEGER array, dimension (NN)
00712 *           The values for the matrix row dimension M.
00713 *
00714 *  line 4:  NVAL, INTEGER array, dimension (NN)
00715 *           The values for the matrix column dimension N.
00716 *
00717 *  line 4:  NK, INTEGER
00718 *           Number of values of K.
00719 *
00720 *  line 5:  KVAL, INTEGER array, dimension (NK)
00721 *           The values for the matrix bandwidth K.
00722 *
00723 *  line 6:  NPARMS, INTEGER
00724 *           Number of values of the parameter NRHS
00725 *
00726 *  line 7:  NSVAL, INTEGER array, dimension (NPARMS)
00727 *           The values for the number of right hand sides NRHS.
00728 *
00729 *  line 8:  THRESH
00730 *           Threshold value for the test ratios.  Information will be
00731 *           printed about each test for which the test ratio is greater
00732 *           than or equal to the threshold.
00733 *
00734 *  line 9:  NEWSD, INTEGER
00735 *           A code indicating how to set the random number seed.
00736 *           = 0:  Set the seed to a default value before each run
00737 *           = 1:  Initialize the seed to a default value only before the
00738 *                 first run
00739 *           = 2:  Like 1, but use the seed values on the next line
00740 *
00741 *  If line 9 was 2:
00742 *
00743 *  line 10: INTEGER array, dimension (4)
00744 *           Four integer values for the random number seed.
00745 *
00746 *  lines 10-EOF:  Lines specifying matrix types, as for SVD.
00747 *           The 3-character path name is 'CBB'.
00748 *
00749 *-----------------------------------------------------------------------
00750 *
00751 *  CEC input file:
00752 *
00753 *  line  2: THRESH, REAL
00754 *           Threshold value for the test ratios.  Information will be
00755 *           printed about each test for which the test ratio is greater
00756 *           than or equal to the threshold.
00757 *
00758 *  lines  3-EOF:
00759 *
00760 *  Input for testing the eigencondition routines consists of a set of
00761 *  specially constructed test cases and their solutions.  The data
00762 *  format is not intended to be modified by the user.
00763 *
00764 *-----------------------------------------------------------------------
00765 *
00766 *  CBL and CBK input files:
00767 *
00768 *  line 1:  'CBL' in columns 1-3 to test CGEBAL, or 'CBK' in
00769 *           columns 1-3 to test CGEBAK.
00770 *
00771 *  The remaining lines consist of specially constructed test cases.
00772 *
00773 *-----------------------------------------------------------------------
00774 *
00775 *  CGL and CGK input files:
00776 *
00777 *  line 1:  'CGL' in columns 1-3 to test CGGBAL, or 'CGK' in
00778 *           columns 1-3 to test CGGBAK.
00779 *
00780 *  The remaining lines consist of specially constructed test cases.
00781 *
00782 *-----------------------------------------------------------------------
00783 *
00784 *  GLM data file:
00785 *
00786 *  line 1:  'GLM' in columns 1 to 3.
00787 *
00788 *  line 2:  NN, INTEGER
00789 *           Number of values of M, P, and N.
00790 *
00791 *  line 3:  MVAL, INTEGER array, dimension(NN)
00792 *           Values of M (row dimension).
00793 *
00794 *  line 4:  PVAL, INTEGER array, dimension(NN)
00795 *           Values of P (row dimension).
00796 *
00797 *  line 5:  NVAL, INTEGER array, dimension(NN)
00798 *           Values of N (column dimension), note M <= N <= M+P.
00799 *
00800 *  line 6:  THRESH, REAL
00801 *           Threshold value for the test ratios.  Information will be
00802 *           printed about each test for which the test ratio is greater
00803 *           than or equal to the threshold.
00804 *
00805 *  line 7:  TSTERR, LOGICAL
00806 *           Flag indicating whether or not to test the error exits for
00807 *           the LAPACK routines and driver routines.
00808 *
00809 *  line 8:  NEWSD, INTEGER
00810 *           A code indicating how to set the random number seed.
00811 *           = 0:  Set the seed to a default value before each run
00812 *           = 1:  Initialize the seed to a default value only before the
00813 *                 first run
00814 *           = 2:  Like 1, but use the seed values on the next line
00815 *
00816 *  If line 8 was 2:
00817 *
00818 *  line 9:  INTEGER array, dimension (4)
00819 *           Four integer values for the random number seed.
00820 *
00821 *  lines 9-EOF:  Lines specifying matrix types, as for NEP.
00822 *           The 3-character path name is 'GLM' for the generalized
00823 *           linear regression model routines.
00824 *
00825 *-----------------------------------------------------------------------
00826 *
00827 *  GQR data file:
00828 *
00829 *  line 1:  'GQR' in columns 1 to 3.
00830 *
00831 *  line 2:  NN, INTEGER
00832 *           Number of values of M, P, and N.
00833 *
00834 *  line 3:  MVAL, INTEGER array, dimension(NN)
00835 *           Values of M.
00836 *
00837 *  line 4:  PVAL, INTEGER array, dimension(NN)
00838 *           Values of P.
00839 *
00840 *  line 5:  NVAL, INTEGER array, dimension(NN)
00841 *           Values of N.
00842 *
00843 *  line 6:  THRESH, REAL
00844 *           Threshold value for the test ratios.  Information will be
00845 *           printed about each test for which the test ratio is greater
00846 *           than or equal to the threshold.
00847 *
00848 *  line 7:  TSTERR, LOGICAL
00849 *           Flag indicating whether or not to test the error exits for
00850 *           the LAPACK routines and driver routines.
00851 *
00852 *  line 8:  NEWSD, INTEGER
00853 *           A code indicating how to set the random number seed.
00854 *           = 0:  Set the seed to a default value before each run
00855 *           = 1:  Initialize the seed to a default value only before the
00856 *                 first run
00857 *           = 2:  Like 1, but use the seed values on the next line
00858 *
00859 *  If line 8 was 2:
00860 *
00861 *  line 9:  INTEGER array, dimension (4)
00862 *           Four integer values for the random number seed.
00863 *
00864 *  lines 9-EOF:  Lines specifying matrix types, as for NEP.
00865 *           The 3-character path name is 'GQR' for the generalized
00866 *           QR and RQ routines.
00867 *
00868 *-----------------------------------------------------------------------
00869 *
00870 *  GSV data file:
00871 *
00872 *  line 1:  'GSV' in columns 1 to 3.
00873 *
00874 *  line 2:  NN, INTEGER
00875 *           Number of values of M, P, and N.
00876 *
00877 *  line 3:  MVAL, INTEGER array, dimension(NN)
00878 *           Values of M (row dimension).
00879 *
00880 *  line 4:  PVAL, INTEGER array, dimension(NN)
00881 *           Values of P (row dimension).
00882 *
00883 *  line 5:  NVAL, INTEGER array, dimension(NN)
00884 *           Values of N (column dimension).
00885 *
00886 *  line 6:  THRESH, REAL
00887 *           Threshold value for the test ratios.  Information will be
00888 *           printed about each test for which the test ratio is greater
00889 *           than or equal to the threshold.
00890 *
00891 *  line 7:  TSTERR, LOGICAL
00892 *           Flag indicating whether or not to test the error exits for
00893 *           the LAPACK routines and driver routines.
00894 *
00895 *  line 8:  NEWSD, INTEGER
00896 *           A code indicating how to set the random number seed.
00897 *           = 0:  Set the seed to a default value before each run
00898 *           = 1:  Initialize the seed to a default value only before the
00899 *                 first run
00900 *           = 2:  Like 1, but use the seed values on the next line
00901 *
00902 *  If line 8 was 2:
00903 *
00904 *  line 9:  INTEGER array, dimension (4)
00905 *           Four integer values for the random number seed.
00906 *
00907 *  lines 9-EOF:  Lines specifying matrix types, as for NEP.
00908 *           The 3-character path name is 'GSV' for the generalized
00909 *           SVD routines.
00910 *
00911 *-----------------------------------------------------------------------
00912 *
00913 *  LSE data file:
00914 *
00915 *  line 1:  'LSE' in columns 1 to 3.
00916 *
00917 *  line 2:  NN, INTEGER
00918 *           Number of values of M, P, and N.
00919 *
00920 *  line 3:  MVAL, INTEGER array, dimension(NN)
00921 *           Values of M.
00922 *
00923 *  line 4:  PVAL, INTEGER array, dimension(NN)
00924 *           Values of P.
00925 *
00926 *  line 5:  NVAL, INTEGER array, dimension(NN)
00927 *           Values of N, note P <= N <= P+M.
00928 *
00929 *  line 6:  THRESH, REAL
00930 *           Threshold value for the test ratios.  Information will be
00931 *           printed about each test for which the test ratio is greater
00932 *           than or equal to the threshold.
00933 *
00934 *  line 7:  TSTERR, LOGICAL
00935 *           Flag indicating whether or not to test the error exits for
00936 *           the LAPACK routines and driver routines.
00937 *
00938 *  line 8:  NEWSD, INTEGER
00939 *           A code indicating how to set the random number seed.
00940 *           = 0:  Set the seed to a default value before each run
00941 *           = 1:  Initialize the seed to a default value only before the
00942 *                 first run
00943 *           = 2:  Like 1, but use the seed values on the next line
00944 *
00945 *  If line 8 was 2:
00946 *
00947 *  line 9:  INTEGER array, dimension (4)
00948 *           Four integer values for the random number seed.
00949 *
00950 *  lines 9-EOF:  Lines specifying matrix types, as for NEP.
00951 *           The 3-character path name is 'GSV' for the generalized
00952 *           SVD routines.
00953 *
00954 *-----------------------------------------------------------------------
00955 *
00956 *  NMAX is currently set to 132 and must be at least 12 for some of the
00957 *  precomputed examples, and LWORK = NMAX*(5*NMAX+20) in the parameter
00958 *  statements below.  For SVD, we assume NRHS may be as big as N.  The
00959 *  parameter NEED is set to 14 to allow for 14 N-by-N matrices for CGG.
00960 *
00961 *  =====================================================================
00962 *
00963 *     .. Parameters ..
00964       INTEGER            NMAX
00965       PARAMETER          ( NMAX = 132 )
00966       INTEGER            NCMAX
00967       PARAMETER          ( NCMAX = 20 )
00968       INTEGER            NEED
00969       PARAMETER          ( NEED = 14 )
00970       INTEGER            LWORK
00971       PARAMETER          ( LWORK = NMAX*( 5*NMAX+20 ) )
00972       INTEGER            LIWORK
00973       PARAMETER          ( LIWORK = NMAX*( NMAX+20 ) )
00974       INTEGER            MAXIN
00975       PARAMETER          ( MAXIN = 20 )
00976       INTEGER            MAXT
00977       PARAMETER          ( MAXT = 30 )
00978       INTEGER            NIN, NOUT
00979       PARAMETER          ( NIN = 5, NOUT = 6 )
00980 *     ..
00981 *     .. Local Scalars ..
00982       LOGICAL            CBB, CBK, CBL, CES, CEV, CGG, CGK, CGL, CGS,
00983      $                   CGV, CGX, CHB, CSX, CVX, CXV, FATAL, GLM, GQR,
00984      $                   GSV, LSE, NEP, SEP, SVD, TSTCHK, TSTDIF,
00985      $                   TSTDRV, TSTERR
00986       CHARACTER          C1
00987       CHARACTER*3        C3, PATH
00988       CHARACTER*32       VNAME
00989       CHARACTER*10       INTSTR
00990       CHARACTER*80       LINE
00991       INTEGER            I, I1, IC, INFO, ITMP, K, LENP, MAXTYP, NEWSD,
00992      $                   NK, NN, NPARMS, NRHS, NTYPES,
00993      $                   VERS_MAJOR, VERS_MINOR, VERS_PATCH 
00994       REAL               EPS, S1, S2, THRESH, THRSHN
00995 *     ..
00996 *     .. Local Arrays ..
00997       LOGICAL            DOTYPE( MAXT ), LOGWRK( NMAX )
00998       INTEGER            IOLDSD( 4 ), ISEED( 4 ), IWORK( LIWORK ),
00999      $                   KVAL( MAXIN ), MVAL( MAXIN ), MXBVAL( MAXIN ),
01000      $                   NBCOL( MAXIN ), NBMIN( MAXIN ), NBVAL( MAXIN ),
01001      $                   NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ),
01002      $                   PVAL( MAXIN )
01003       INTEGER            INMIN( MAXIN ), INWIN( MAXIN ), INIBL( MAXIN ),
01004      $                   ISHFTS( MAXIN ), IACC22( MAXIN )
01005       REAL               ALPHA( NMAX ), BETA( NMAX ), DR( NMAX, 12 ),
01006      $                   RESULT( 500 ), RWORK( LWORK ), S( NMAX*NMAX )
01007       COMPLEX            A( NMAX*NMAX, NEED ), B( NMAX*NMAX, 5 ),
01008      $                   C( NCMAX*NCMAX, NCMAX*NCMAX ), DC( NMAX, 6 ),
01009      $                   TAUA( NMAX ), TAUB( NMAX ), WORK( LWORK ),
01010      $                   X( 5*NMAX )
01011 *     ..
01012 *     .. External Functions ..
01013       LOGICAL            LSAMEN
01014       REAL               SECOND, SLAMCH
01015       EXTERNAL           LSAMEN, SECOND, SLAMCH
01016 *     ..
01017 *     .. External Subroutines ..
01018       EXTERNAL           ALAREQ, CCHKBB, CCHKBD, CCHKBK, CCHKBL, CCHKEC,
01019      $                   CCHKGG, CCHKGK, CCHKGL, CCHKHB, CCHKHS, CCHKST,
01020      $                   CCKGLM, CCKGQR, CCKGSV, CCKLSE, CDRGES, CDRGEV,
01021      $                   CDRGSX, CDRGVX, CDRVBD, CDRVES, CDRVEV, CDRVGG,
01022      $                   CDRVSG, CDRVST, CDRVSX, CDRVVX, CERRBD, CERRED,
01023      $                   CERRGG, CERRHS, CERRST, ILAVER, XLAENV
01024 *     ..
01025 *     .. Intrinsic Functions ..
01026       INTRINSIC          LEN, MIN
01027 *     ..
01028 *     .. Scalars in Common ..
01029       LOGICAL            LERR, OK
01030       CHARACTER*32       SRNAMT
01031       INTEGER            INFOT, MAXB, NPROC, NSHIFT, NUNIT, SELDIM,
01032      $                   SELOPT
01033 *     ..
01034 *     .. Arrays in Common ..
01035       LOGICAL            SELVAL( 20 )
01036       INTEGER            IPARMS( 100 )
01037       REAL               SELWI( 20 ), SELWR( 20 )
01038 *     ..
01039 *     .. Common blocks ..
01040       COMMON             / CENVIR / NPROC, NSHIFT, MAXB
01041       COMMON             / CLAENV / IPARMS
01042       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
01043       COMMON             / SRNAMC / SRNAMT
01044       COMMON             / SSLCT / SELOPT, SELDIM, SELVAL, SELWR, SELWI
01045 *     ..
01046 *     .. Data statements ..
01047       DATA               INTSTR / '0123456789' /
01048       DATA               IOLDSD / 0, 0, 0, 1 /
01049 *     ..
01050 *     .. Executable Statements ..
01051 *
01052       S1 = SECOND( )
01053       FATAL = .FALSE.
01054       NUNIT = NOUT
01055 *
01056 *     Return to here to read multiple sets of data
01057 *
01058    10 CONTINUE
01059 *
01060 *     Read the first line and set the 3-character test path
01061 *
01062       READ( NIN, FMT = '(A80)', END = 380 )LINE
01063       PATH = LINE( 1: 3 )
01064       NEP = LSAMEN( 3, PATH, 'NEP' ) .OR. LSAMEN( 3, PATH, 'CHS' )
01065       SEP = LSAMEN( 3, PATH, 'SEP' ) .OR. LSAMEN( 3, PATH, 'CST' ) .OR.
01066      $      LSAMEN( 3, PATH, 'CSG' )
01067       SVD = LSAMEN( 3, PATH, 'SVD' ) .OR. LSAMEN( 3, PATH, 'CBD' )
01068       CEV = LSAMEN( 3, PATH, 'CEV' )
01069       CES = LSAMEN( 3, PATH, 'CES' )
01070       CVX = LSAMEN( 3, PATH, 'CVX' )
01071       CSX = LSAMEN( 3, PATH, 'CSX' )
01072       CGG = LSAMEN( 3, PATH, 'CGG' )
01073       CGS = LSAMEN( 3, PATH, 'CGS' )
01074       CGX = LSAMEN( 3, PATH, 'CGX' )
01075       CGV = LSAMEN( 3, PATH, 'CGV' )
01076       CXV = LSAMEN( 3, PATH, 'CXV' )
01077       CHB = LSAMEN( 3, PATH, 'CHB' )
01078       CBB = LSAMEN( 3, PATH, 'CBB' )
01079       GLM = LSAMEN( 3, PATH, 'GLM' )
01080       GQR = LSAMEN( 3, PATH, 'GQR' ) .OR. LSAMEN( 3, PATH, 'GRQ' )
01081       GSV = LSAMEN( 3, PATH, 'GSV' )
01082       LSE = LSAMEN( 3, PATH, 'LSE' )
01083       CBL = LSAMEN( 3, PATH, 'CBL' )
01084       CBK = LSAMEN( 3, PATH, 'CBK' )
01085       CGL = LSAMEN( 3, PATH, 'CGL' )
01086       CGK = LSAMEN( 3, PATH, 'CGK' )
01087 *
01088 *     Report values of parameters.
01089 *
01090       IF( PATH.EQ.'   ' ) THEN
01091          GO TO 10
01092       ELSE IF( NEP ) THEN
01093          WRITE( NOUT, FMT = 9987 )
01094       ELSE IF( SEP ) THEN
01095          WRITE( NOUT, FMT = 9986 )
01096       ELSE IF( SVD ) THEN
01097          WRITE( NOUT, FMT = 9985 )
01098       ELSE IF( CEV ) THEN
01099          WRITE( NOUT, FMT = 9979 )
01100       ELSE IF( CES ) THEN
01101          WRITE( NOUT, FMT = 9978 )
01102       ELSE IF( CVX ) THEN
01103          WRITE( NOUT, FMT = 9977 )
01104       ELSE IF( CSX ) THEN
01105          WRITE( NOUT, FMT = 9976 )
01106       ELSE IF( CGG ) THEN
01107          WRITE( NOUT, FMT = 9975 )
01108       ELSE IF( CGS ) THEN
01109          WRITE( NOUT, FMT = 9964 )
01110       ELSE IF( CGX ) THEN
01111          WRITE( NOUT, FMT = 9965 )
01112       ELSE IF( CGV ) THEN
01113          WRITE( NOUT, FMT = 9963 )
01114       ELSE IF( CXV ) THEN
01115          WRITE( NOUT, FMT = 9962 )
01116       ELSE IF( CHB ) THEN
01117          WRITE( NOUT, FMT = 9974 )
01118       ELSE IF( CBB ) THEN
01119          WRITE( NOUT, FMT = 9967 )
01120       ELSE IF( GLM ) THEN
01121          WRITE( NOUT, FMT = 9971 )
01122       ELSE IF( GQR ) THEN
01123          WRITE( NOUT, FMT = 9970 )
01124       ELSE IF( GSV ) THEN
01125          WRITE( NOUT, FMT = 9969 )
01126       ELSE IF( LSE ) THEN
01127          WRITE( NOUT, FMT = 9968 )
01128       ELSE IF( CBL ) THEN
01129 *
01130 *        CGEBAL:  Balancing
01131 *
01132          CALL CCHKBL( NIN, NOUT )
01133          GO TO 380
01134       ELSE IF( CBK ) THEN
01135 *
01136 *        CGEBAK:  Back transformation
01137 *
01138          CALL CCHKBK( NIN, NOUT )
01139          GO TO 380
01140       ELSE IF( CGL ) THEN
01141 *
01142 *        CGGBAL:  Balancing
01143 *
01144          CALL CCHKGL( NIN, NOUT )
01145          GO TO 380
01146       ELSE IF( CGK ) THEN
01147 *
01148 *        CGGBAK:  Back transformation
01149 *
01150          CALL CCHKGK( NIN, NOUT )
01151          GO TO 380
01152       ELSE IF( LSAMEN( 3, PATH, 'CEC' ) ) THEN
01153 *
01154 *        CEC:  Eigencondition estimation
01155 *
01156          READ( NIN, FMT = * )THRESH
01157          CALL XLAENV( 1, 1 )
01158          TSTERR = .TRUE.
01159          CALL CCHKEC( THRESH, TSTERR, NIN, NOUT )
01160          GO TO 380
01161       ELSE
01162          WRITE( NOUT, FMT = 9992 )PATH
01163          GO TO 380
01164       END IF
01165       CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH ) 
01166       WRITE( NOUT, FMT = 9972 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH
01167       WRITE( NOUT, FMT = 9984 )
01168 *
01169 *     Read the number of values of M, P, and N.
01170 *
01171       READ( NIN, FMT = * )NN
01172       IF( NN.LT.0 ) THEN
01173          WRITE( NOUT, FMT = 9989 )'   NN ', NN, 1
01174          NN = 0
01175          FATAL = .TRUE.
01176       ELSE IF( NN.GT.MAXIN ) THEN
01177          WRITE( NOUT, FMT = 9988 )'   NN ', NN, MAXIN
01178          NN = 0
01179          FATAL = .TRUE.
01180       END IF
01181 *
01182 *     Read the values of M
01183 *
01184       IF( .NOT.( CGX .OR. CXV ) ) THEN
01185          READ( NIN, FMT = * )( MVAL( I ), I = 1, NN )
01186          IF( SVD ) THEN
01187             VNAME = '    M '
01188          ELSE
01189             VNAME = '    N '
01190          END IF
01191          DO 20 I = 1, NN
01192             IF( MVAL( I ).LT.0 ) THEN
01193                WRITE( NOUT, FMT = 9989 )VNAME, MVAL( I ), 0
01194                FATAL = .TRUE.
01195             ELSE IF( MVAL( I ).GT.NMAX ) THEN
01196                WRITE( NOUT, FMT = 9988 )VNAME, MVAL( I ), NMAX
01197                FATAL = .TRUE.
01198             END IF
01199    20    CONTINUE
01200          WRITE( NOUT, FMT = 9983 )'M:    ', ( MVAL( I ), I = 1, NN )
01201       END IF
01202 *
01203 *     Read the values of P
01204 *
01205       IF( GLM .OR. GQR .OR. GSV .OR. LSE ) THEN
01206          READ( NIN, FMT = * )( PVAL( I ), I = 1, NN )
01207          DO 30 I = 1, NN
01208             IF( PVAL( I ).LT.0 ) THEN
01209                WRITE( NOUT, FMT = 9989 )' P  ', PVAL( I ), 0
01210                FATAL = .TRUE.
01211             ELSE IF( PVAL( I ).GT.NMAX ) THEN
01212                WRITE( NOUT, FMT = 9988 )' P  ', PVAL( I ), NMAX
01213                FATAL = .TRUE.
01214             END IF
01215    30    CONTINUE
01216          WRITE( NOUT, FMT = 9983 )'P:    ', ( PVAL( I ), I = 1, NN )
01217       END IF
01218 *
01219 *     Read the values of N
01220 *
01221       IF( SVD .OR. CBB .OR. GLM .OR. GQR .OR. GSV .OR. LSE ) THEN
01222          READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
01223          DO 40 I = 1, NN
01224             IF( NVAL( I ).LT.0 ) THEN
01225                WRITE( NOUT, FMT = 9989 )'    N ', NVAL( I ), 0
01226                FATAL = .TRUE.
01227             ELSE IF( NVAL( I ).GT.NMAX ) THEN
01228                WRITE( NOUT, FMT = 9988 )'    N ', NVAL( I ), NMAX
01229                FATAL = .TRUE.
01230             END IF
01231    40    CONTINUE
01232       ELSE
01233          DO 50 I = 1, NN
01234             NVAL( I ) = MVAL( I )
01235    50    CONTINUE
01236       END IF
01237       IF( .NOT.( CGX .OR. CXV ) ) THEN
01238          WRITE( NOUT, FMT = 9983 )'N:    ', ( NVAL( I ), I = 1, NN )
01239       ELSE
01240          WRITE( NOUT, FMT = 9983 )'N:    ', NN
01241       END IF
01242 *
01243 *     Read the number of values of K, followed by the values of K
01244 *
01245       IF( CHB .OR. CBB ) THEN
01246          READ( NIN, FMT = * )NK
01247          READ( NIN, FMT = * )( KVAL( I ), I = 1, NK )
01248          DO 60 I = 1, NK
01249             IF( KVAL( I ).LT.0 ) THEN
01250                WRITE( NOUT, FMT = 9989 )'    K ', KVAL( I ), 0
01251                FATAL = .TRUE.
01252             ELSE IF( KVAL( I ).GT.NMAX ) THEN
01253                WRITE( NOUT, FMT = 9988 )'    K ', KVAL( I ), NMAX
01254                FATAL = .TRUE.
01255             END IF
01256    60    CONTINUE
01257          WRITE( NOUT, FMT = 9983 )'K:    ', ( KVAL( I ), I = 1, NK )
01258       END IF
01259 *
01260       IF( CEV .OR. CES .OR. CVX .OR. CSX ) THEN
01261 *
01262 *        For the nonsymmetric QR driver routines, only one set of
01263 *        parameters is allowed.
01264 *
01265          READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ),
01266      $      INMIN( 1 ), INWIN( 1 ), INIBL(1), ISHFTS(1), IACC22(1)
01267          IF( NBVAL( 1 ).LT.1 ) THEN
01268             WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( 1 ), 1
01269             FATAL = .TRUE.
01270          ELSE IF( NBMIN( 1 ).LT.1 ) THEN
01271             WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1
01272             FATAL = .TRUE.
01273          ELSE IF( NXVAL( 1 ).LT.1 ) THEN
01274             WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( 1 ), 1
01275             FATAL = .TRUE.
01276          ELSE IF( INMIN( 1 ).LT.1 ) THEN
01277             WRITE( NOUT, FMT = 9989 )'   INMIN ', INMIN( 1 ), 1
01278             FATAL = .TRUE.
01279          ELSE IF( INWIN( 1 ).LT.1 ) THEN
01280             WRITE( NOUT, FMT = 9989 )'   INWIN ', INWIN( 1 ), 1
01281             FATAL = .TRUE.
01282          ELSE IF( INIBL( 1 ).LT.1 ) THEN
01283             WRITE( NOUT, FMT = 9989 )'   INIBL ', INIBL( 1 ), 1
01284             FATAL = .TRUE.
01285          ELSE IF( ISHFTS( 1 ).LT.1 ) THEN
01286             WRITE( NOUT, FMT = 9989 )'   ISHFTS ', ISHFTS( 1 ), 1
01287             FATAL = .TRUE.
01288          ELSE IF( IACC22( 1 ).LT.0 ) THEN
01289             WRITE( NOUT, FMT = 9989 )'   IACC22 ', IACC22( 1 ), 0
01290             FATAL = .TRUE.
01291          END IF
01292          CALL XLAENV( 1, NBVAL( 1 ) )
01293          CALL XLAENV( 2, NBMIN( 1 ) )
01294          CALL XLAENV( 3, NXVAL( 1 ) )
01295          CALL XLAENV(12, MAX( 11, INMIN( 1 ) ) )
01296          CALL XLAENV(13, INWIN( 1 ) )
01297          CALL XLAENV(14, INIBL( 1 ) )
01298          CALL XLAENV(15, ISHFTS( 1 ) )
01299          CALL XLAENV(16, IACC22( 1 ) )
01300          WRITE( NOUT, FMT = 9983 )'NB:   ', NBVAL( 1 )
01301          WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 )
01302          WRITE( NOUT, FMT = 9983 )'NX:   ', NXVAL( 1 )
01303          WRITE( NOUT, FMT = 9983 )'INMIN:   ', INMIN( 1 )
01304          WRITE( NOUT, FMT = 9983 )'INWIN: ', INWIN( 1 )
01305          WRITE( NOUT, FMT = 9983 )'INIBL: ', INIBL( 1 )
01306          WRITE( NOUT, FMT = 9983 )'ISHFTS: ', ISHFTS( 1 )
01307          WRITE( NOUT, FMT = 9983 )'IACC22: ', IACC22( 1 )
01308 *
01309       ELSE IF( CGS .OR. CGX .OR. CGV .OR. CXV ) THEN
01310 *
01311 *        For the nonsymmetric generalized driver routines, only one set of
01312 *        parameters is allowed.
01313 *
01314          READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ),
01315      $      NSVAL( 1 ), MXBVAL( 1 )
01316          IF( NBVAL( 1 ).LT.1 ) THEN
01317             WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( 1 ), 1
01318             FATAL = .TRUE.
01319          ELSE IF( NBMIN( 1 ).LT.1 ) THEN
01320             WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1
01321             FATAL = .TRUE.
01322          ELSE IF( NXVAL( 1 ).LT.1 ) THEN
01323             WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( 1 ), 1
01324             FATAL = .TRUE.
01325          ELSE IF( NSVAL( 1 ).LT.2 ) THEN
01326             WRITE( NOUT, FMT = 9989 )'   NS ', NSVAL( 1 ), 2
01327             FATAL = .TRUE.
01328          ELSE IF( MXBVAL( 1 ).LT.1 ) THEN
01329             WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( 1 ), 1
01330             FATAL = .TRUE.
01331          END IF
01332          CALL XLAENV( 1, NBVAL( 1 ) )
01333          CALL XLAENV( 2, NBMIN( 1 ) )
01334          CALL XLAENV( 3, NXVAL( 1 ) )
01335          CALL XLAENV( 4, NSVAL( 1 ) )
01336          CALL XLAENV( 8, MXBVAL( 1 ) )
01337          WRITE( NOUT, FMT = 9983 )'NB:   ', NBVAL( 1 )
01338          WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 )
01339          WRITE( NOUT, FMT = 9983 )'NX:   ', NXVAL( 1 )
01340          WRITE( NOUT, FMT = 9983 )'NS:   ', NSVAL( 1 )
01341          WRITE( NOUT, FMT = 9983 )'MAXB: ', MXBVAL( 1 )
01342       ELSE IF( .NOT.CHB .AND. .NOT.GLM .AND. .NOT.GQR .AND. .NOT.
01343      $         GSV .AND. .NOT.LSE ) THEN
01344 *
01345 *        For the other paths, the number of parameters can be varied
01346 *        from the input file.  Read the number of parameter values.
01347 *
01348          READ( NIN, FMT = * )NPARMS
01349          IF( NPARMS.LT.1 ) THEN
01350             WRITE( NOUT, FMT = 9989 )'NPARMS', NPARMS, 1
01351             NPARMS = 0
01352             FATAL = .TRUE.
01353          ELSE IF( NPARMS.GT.MAXIN ) THEN
01354             WRITE( NOUT, FMT = 9988 )'NPARMS', NPARMS, MAXIN
01355             NPARMS = 0
01356             FATAL = .TRUE.
01357          END IF
01358 *
01359 *        Read the values of NB
01360 *
01361          IF( .NOT.CBB ) THEN
01362             READ( NIN, FMT = * )( NBVAL( I ), I = 1, NPARMS )
01363             DO 70 I = 1, NPARMS
01364                IF( NBVAL( I ).LT.0 ) THEN
01365                   WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( I ), 0
01366                   FATAL = .TRUE.
01367                ELSE IF( NBVAL( I ).GT.NMAX ) THEN
01368                   WRITE( NOUT, FMT = 9988 )'   NB ', NBVAL( I ), NMAX
01369                   FATAL = .TRUE.
01370                END IF
01371    70       CONTINUE
01372             WRITE( NOUT, FMT = 9983 )'NB:   ',
01373      $         ( NBVAL( I ), I = 1, NPARMS )
01374          END IF
01375 *
01376 *        Read the values of NBMIN
01377 *
01378          IF( NEP .OR. SEP .OR. SVD .OR. CGG ) THEN
01379             READ( NIN, FMT = * )( NBMIN( I ), I = 1, NPARMS )
01380             DO 80 I = 1, NPARMS
01381                IF( NBMIN( I ).LT.0 ) THEN
01382                   WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( I ), 0
01383                   FATAL = .TRUE.
01384                ELSE IF( NBMIN( I ).GT.NMAX ) THEN
01385                   WRITE( NOUT, FMT = 9988 )'NBMIN ', NBMIN( I ), NMAX
01386                   FATAL = .TRUE.
01387                END IF
01388    80       CONTINUE
01389             WRITE( NOUT, FMT = 9983 )'NBMIN:',
01390      $         ( NBMIN( I ), I = 1, NPARMS )
01391          ELSE
01392             DO 90 I = 1, NPARMS
01393                NBMIN( I ) = 1
01394    90       CONTINUE
01395          END IF
01396 *
01397 *        Read the values of NX
01398 *
01399          IF( NEP .OR. SEP .OR. SVD ) THEN
01400             READ( NIN, FMT = * )( NXVAL( I ), I = 1, NPARMS )
01401             DO 100 I = 1, NPARMS
01402                IF( NXVAL( I ).LT.0 ) THEN
01403                   WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( I ), 0
01404                   FATAL = .TRUE.
01405                ELSE IF( NXVAL( I ).GT.NMAX ) THEN
01406                   WRITE( NOUT, FMT = 9988 )'   NX ', NXVAL( I ), NMAX
01407                   FATAL = .TRUE.
01408                END IF
01409   100       CONTINUE
01410             WRITE( NOUT, FMT = 9983 )'NX:   ',
01411      $         ( NXVAL( I ), I = 1, NPARMS )
01412          ELSE
01413             DO 110 I = 1, NPARMS
01414                NXVAL( I ) = 1
01415   110       CONTINUE
01416          END IF
01417 *
01418 *        Read the values of NSHIFT (if CGG) or NRHS (if SVD
01419 *        or CBB).
01420 *
01421          IF( SVD .OR. CBB .OR. CGG ) THEN
01422             READ( NIN, FMT = * )( NSVAL( I ), I = 1, NPARMS )
01423             DO 120 I = 1, NPARMS
01424                IF( NSVAL( I ).LT.0 ) THEN
01425                   WRITE( NOUT, FMT = 9989 )'   NS ', NSVAL( I ), 0
01426                   FATAL = .TRUE.
01427                ELSE IF( NSVAL( I ).GT.NMAX ) THEN
01428                   WRITE( NOUT, FMT = 9988 )'   NS ', NSVAL( I ), NMAX
01429                   FATAL = .TRUE.
01430                END IF
01431   120       CONTINUE
01432             WRITE( NOUT, FMT = 9983 )'NS:   ',
01433      $         ( NSVAL( I ), I = 1, NPARMS )
01434          ELSE
01435             DO 130 I = 1, NPARMS
01436                NSVAL( I ) = 1
01437   130       CONTINUE
01438          END IF
01439 *
01440 *        Read the values for MAXB.
01441 *
01442          IF( CGG ) THEN
01443             READ( NIN, FMT = * )( MXBVAL( I ), I = 1, NPARMS )
01444             DO 140 I = 1, NPARMS
01445                IF( MXBVAL( I ).LT.0 ) THEN
01446                   WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( I ), 0
01447                   FATAL = .TRUE.
01448                ELSE IF( MXBVAL( I ).GT.NMAX ) THEN
01449                   WRITE( NOUT, FMT = 9988 )' MAXB ', MXBVAL( I ), NMAX
01450                   FATAL = .TRUE.
01451                END IF
01452   140       CONTINUE
01453             WRITE( NOUT, FMT = 9983 )'MAXB: ',
01454      $         ( MXBVAL( I ), I = 1, NPARMS )
01455          ELSE
01456             DO 150 I = 1, NPARMS
01457                MXBVAL( I ) = 1
01458   150       CONTINUE
01459          END IF
01460 *
01461 *        Read the values for INMIN.
01462 *
01463          IF( NEP ) THEN
01464             READ( NIN, FMT = * )( INMIN( I ), I = 1, NPARMS )
01465             DO 540 I = 1, NPARMS
01466                IF( INMIN( I ).LT.0 ) THEN
01467                   WRITE( NOUT, FMT = 9989 )' INMIN ', INMIN( I ), 0
01468                   FATAL = .TRUE.
01469                END IF
01470   540       CONTINUE
01471             WRITE( NOUT, FMT = 9983 )'INMIN: ',
01472      $         ( INMIN( I ), I = 1, NPARMS )
01473          ELSE
01474             DO 550 I = 1, NPARMS
01475                INMIN( I ) = 1
01476   550       CONTINUE
01477          END IF
01478 *
01479 *        Read the values for INWIN.
01480 *
01481          IF( NEP ) THEN
01482             READ( NIN, FMT = * )( INWIN( I ), I = 1, NPARMS )
01483             DO 560 I = 1, NPARMS
01484                IF( INWIN( I ).LT.0 ) THEN
01485                   WRITE( NOUT, FMT = 9989 )' INWIN ', INWIN( I ), 0
01486                   FATAL = .TRUE.
01487                END IF
01488   560       CONTINUE
01489             WRITE( NOUT, FMT = 9983 )'INWIN: ',
01490      $         ( INWIN( I ), I = 1, NPARMS )
01491          ELSE
01492             DO 570 I = 1, NPARMS
01493                INWIN( I ) = 1
01494   570       CONTINUE
01495          END IF
01496 *
01497 *        Read the values for INIBL.
01498 *
01499          IF( NEP ) THEN
01500             READ( NIN, FMT = * )( INIBL( I ), I = 1, NPARMS )
01501             DO 580 I = 1, NPARMS
01502                IF( INIBL( I ).LT.0 ) THEN
01503                   WRITE( NOUT, FMT = 9989 )' INIBL ', INIBL( I ), 0
01504                   FATAL = .TRUE.
01505                END IF
01506   580       CONTINUE
01507             WRITE( NOUT, FMT = 9983 )'INIBL: ',
01508      $         ( INIBL( I ), I = 1, NPARMS )
01509          ELSE
01510             DO 590 I = 1, NPARMS
01511                INIBL( I ) = 1
01512   590       CONTINUE
01513          END IF
01514 *
01515 *        Read the values for ISHFTS.
01516 *
01517          IF( NEP ) THEN
01518             READ( NIN, FMT = * )( ISHFTS( I ), I = 1, NPARMS )
01519             DO 600 I = 1, NPARMS
01520                IF( ISHFTS( I ).LT.0 ) THEN
01521                   WRITE( NOUT, FMT = 9989 )' ISHFTS ', ISHFTS( I ), 0
01522                   FATAL = .TRUE.
01523                END IF
01524   600       CONTINUE
01525             WRITE( NOUT, FMT = 9983 )'ISHFTS: ',
01526      $         ( ISHFTS( I ), I = 1, NPARMS )
01527          ELSE
01528             DO 610 I = 1, NPARMS
01529                ISHFTS( I ) = 1
01530   610       CONTINUE
01531          END IF
01532 *
01533 *        Read the values for IACC22.
01534 *
01535          IF( NEP ) THEN
01536             READ( NIN, FMT = * )( IACC22( I ), I = 1, NPARMS )
01537             DO 620 I = 1, NPARMS
01538                IF( IACC22( I ).LT.0 ) THEN
01539                   WRITE( NOUT, FMT = 9989 )' IACC22 ', IACC22( I ), 0
01540                   FATAL = .TRUE.
01541                END IF
01542   620       CONTINUE
01543             WRITE( NOUT, FMT = 9983 )'IACC22: ',
01544      $         ( IACC22( I ), I = 1, NPARMS )
01545          ELSE
01546             DO 630 I = 1, NPARMS
01547                IACC22( I ) = 1
01548   630       CONTINUE
01549          END IF
01550 *
01551 *        Read the values for NBCOL.
01552 *
01553          IF( CGG ) THEN
01554             READ( NIN, FMT = * )( NBCOL( I ), I = 1, NPARMS )
01555             DO 160 I = 1, NPARMS
01556                IF( NBCOL( I ).LT.0 ) THEN
01557                   WRITE( NOUT, FMT = 9989 )'NBCOL ', NBCOL( I ), 0
01558                   FATAL = .TRUE.
01559                ELSE IF( NBCOL( I ).GT.NMAX ) THEN
01560                   WRITE( NOUT, FMT = 9988 )'NBCOL ', NBCOL( I ), NMAX
01561                   FATAL = .TRUE.
01562                END IF
01563   160       CONTINUE
01564             WRITE( NOUT, FMT = 9983 )'NBCOL:',
01565      $         ( NBCOL( I ), I = 1, NPARMS )
01566          ELSE
01567             DO 170 I = 1, NPARMS
01568                NBCOL( I ) = 1
01569   170       CONTINUE
01570          END IF
01571       END IF
01572 *
01573 *     Calculate and print the machine dependent constants.
01574 *
01575       WRITE( NOUT, FMT = * )
01576       EPS = SLAMCH( 'Underflow threshold' )
01577       WRITE( NOUT, FMT = 9981 )'underflow', EPS
01578       EPS = SLAMCH( 'Overflow threshold' )
01579       WRITE( NOUT, FMT = 9981 )'overflow ', EPS
01580       EPS = SLAMCH( 'Epsilon' )
01581       WRITE( NOUT, FMT = 9981 )'precision', EPS
01582 *
01583 *     Read the threshold value for the test ratios.
01584 *
01585       READ( NIN, FMT = * )THRESH
01586       WRITE( NOUT, FMT = 9982 )THRESH
01587       IF( SEP .OR. SVD .OR. CGG ) THEN
01588 *
01589 *        Read the flag that indicates whether to test LAPACK routines.
01590 *
01591          READ( NIN, FMT = * )TSTCHK
01592 *
01593 *        Read the flag that indicates whether to test driver routines.
01594 *
01595          READ( NIN, FMT = * )TSTDRV
01596       END IF
01597 *
01598 *     Read the flag that indicates whether to test the error exits.
01599 *
01600       READ( NIN, FMT = * )TSTERR
01601 *
01602 *     Read the code describing how to set the random number seed.
01603 *
01604       READ( NIN, FMT = * )NEWSD
01605 *
01606 *     If NEWSD = 2, read another line with 4 integers for the seed.
01607 *
01608       IF( NEWSD.EQ.2 )
01609      $   READ( NIN, FMT = * )( IOLDSD( I ), I = 1, 4 )
01610 *
01611       DO 180 I = 1, 4
01612          ISEED( I ) = IOLDSD( I )
01613   180 CONTINUE
01614 *
01615       IF( FATAL ) THEN
01616          WRITE( NOUT, FMT = 9999 )
01617          STOP
01618       END IF
01619 *
01620 *     Read the input lines indicating the test path and its parameters.
01621 *     The first three characters indicate the test path, and the number
01622 *     of test matrix types must be the first nonblank item in columns
01623 *     4-80.
01624 *
01625   190 CONTINUE
01626 *
01627       IF( .NOT.( CGX .OR. CXV ) ) THEN
01628 *
01629   200    CONTINUE
01630          READ( NIN, FMT = '(A80)', END = 380 )LINE
01631          C3 = LINE( 1: 3 )
01632          LENP = LEN( LINE )
01633          I = 3
01634          ITMP = 0
01635          I1 = 0
01636   210    CONTINUE
01637          I = I + 1
01638          IF( I.GT.LENP ) THEN
01639             IF( I1.GT.0 ) THEN
01640                GO TO 240
01641             ELSE
01642                NTYPES = MAXT
01643                GO TO 240
01644             END IF
01645          END IF
01646          IF( LINE( I: I ).NE.' ' .AND. LINE( I: I ).NE.',' ) THEN
01647             I1 = I
01648             C1 = LINE( I1: I1 )
01649 *
01650 *        Check that a valid integer was read
01651 *
01652             DO 220 K = 1, 10
01653                IF( C1.EQ.INTSTR( K: K ) ) THEN
01654                   IC = K - 1
01655                   GO TO 230
01656                END IF
01657   220       CONTINUE
01658             WRITE( NOUT, FMT = 9991 )I, LINE
01659             GO TO 200
01660   230       CONTINUE
01661             ITMP = 10*ITMP + IC
01662             GO TO 210
01663          ELSE IF( I1.GT.0 ) THEN
01664             GO TO 240
01665          ELSE
01666             GO TO 210
01667          END IF
01668   240    CONTINUE
01669          NTYPES = ITMP
01670 *
01671 *     Skip the tests if NTYPES is <= 0.
01672 *
01673          IF( .NOT.( CEV .OR. CES .OR. CVX .OR. CSX .OR. CGV .OR.
01674      $       CGS ) .AND. NTYPES.LE.0 ) THEN
01675             WRITE( NOUT, FMT = 9990 )C3
01676             GO TO 200
01677          END IF
01678 *
01679       ELSE
01680          IF( CGX )
01681      $      C3 = 'CGX'
01682          IF( CXV )
01683      $      C3 = 'CXV'
01684       END IF
01685 *
01686 *     Reset the random number seed.
01687 *
01688       IF( NEWSD.EQ.0 ) THEN
01689          DO 250 K = 1, 4
01690             ISEED( K ) = IOLDSD( K )
01691   250    CONTINUE
01692       END IF
01693 *
01694       IF( LSAMEN( 3, C3, 'CHS' ) .OR. LSAMEN( 3, C3, 'NEP' ) ) THEN
01695 *
01696 *        -------------------------------------
01697 *        NEP:  Nonsymmetric Eigenvalue Problem
01698 *        -------------------------------------
01699 *        Vary the parameters
01700 *           NB    = block size
01701 *           NBMIN = minimum block size
01702 *           NX    = crossover point
01703 *           NS    = number of shifts
01704 *           MAXB  = minimum submatrix size
01705 *
01706          MAXTYP = 21
01707          NTYPES = MIN( MAXTYP, NTYPES )
01708          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01709          CALL XLAENV( 1, 1 )
01710          IF( TSTERR )
01711      $      CALL CERRHS( 'CHSEQR', NOUT )
01712          DO 270 I = 1, NPARMS
01713             CALL XLAENV( 1, NBVAL( I ) )
01714             CALL XLAENV( 2, NBMIN( I ) )
01715             CALL XLAENV( 3, NXVAL( I ) )
01716             CALL XLAENV(12, MAX( 11, INMIN( I ) ) )
01717             CALL XLAENV(13, INWIN( I ) )
01718             CALL XLAENV(14, INIBL( I ) )
01719             CALL XLAENV(15, ISHFTS( I ) )
01720             CALL XLAENV(16, IACC22( I ) )
01721 *
01722             IF( NEWSD.EQ.0 ) THEN
01723                DO 260 K = 1, 4
01724                   ISEED( K ) = IOLDSD( K )
01725   260          CONTINUE
01726             END IF
01727             WRITE( NOUT, FMT = 9961 )C3, NBVAL( I ), NBMIN( I ),
01728      $         NXVAL( I ), MAX( 11, INMIN(I)),
01729      $         INWIN( I ), INIBL( I ), ISHFTS( I ), IACC22( I )
01730             CALL CCHKHS( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
01731      $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
01732      $                   A( 1, 4 ), A( 1, 5 ), NMAX, A( 1, 6 ),
01733      $                   A( 1, 7 ), DC( 1, 1 ), DC( 1, 2 ), A( 1, 8 ),
01734      $                   A( 1, 9 ), A( 1, 10 ), A( 1, 11 ), A( 1, 12 ),
01735      $                   DC( 1, 3 ), WORK, LWORK, RWORK, IWORK, LOGWRK,
01736      $                   RESULT, INFO )
01737             IF( INFO.NE.0 )
01738      $         WRITE( NOUT, FMT = 9980 )'CCHKHS', INFO
01739   270    CONTINUE
01740 *
01741       ELSE IF( LSAMEN( 3, C3, 'CST' ) .OR. LSAMEN( 3, C3, 'SEP' ) ) THEN
01742 *
01743 *        ----------------------------------
01744 *        SEP:  Symmetric Eigenvalue Problem
01745 *        ----------------------------------
01746 *        Vary the parameters
01747 *           NB    = block size
01748 *           NBMIN = minimum block size
01749 *           NX    = crossover point
01750 *
01751          MAXTYP = 21
01752          NTYPES = MIN( MAXTYP, NTYPES )
01753          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01754          CALL XLAENV( 1, 1 )
01755          CALL XLAENV( 9, 25 )
01756          IF( TSTERR )
01757      $      CALL CERRST( 'CST', NOUT )
01758          DO 290 I = 1, NPARMS
01759             CALL XLAENV( 1, NBVAL( I ) )
01760             CALL XLAENV( 2, NBMIN( I ) )
01761             CALL XLAENV( 3, NXVAL( I ) )
01762 *
01763             IF( NEWSD.EQ.0 ) THEN
01764                DO 280 K = 1, 4
01765                   ISEED( K ) = IOLDSD( K )
01766   280          CONTINUE
01767             END IF
01768             WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ),
01769      $         NXVAL( I )
01770             IF( TSTCHK ) THEN
01771                CALL CCHKST( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
01772      $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ),
01773      $                      DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
01774      $                      DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
01775      $                      DR( 1, 7 ), DR( 1, 8 ), DR( 1, 9 ),
01776      $                      DR( 1, 10 ), DR( 1, 11 ), A( 1, 3 ), NMAX,
01777      $                      A( 1, 4 ), A( 1, 5 ), DC( 1, 1 ), A( 1, 6 ),
01778      $                      WORK, LWORK, RWORK, LWORK, IWORK, LIWORK, 
01779      $                      RESULT, INFO )
01780                IF( INFO.NE.0 )
01781      $            WRITE( NOUT, FMT = 9980 )'CCHKST', INFO
01782             END IF
01783             IF( TSTDRV ) THEN
01784                CALL CDRVST( NN, NVAL, 18, DOTYPE, ISEED, THRESH, NOUT,
01785      $                      A( 1, 1 ), NMAX, DR( 1, 3 ), DR( 1, 4 ),
01786      $                      DR( 1, 5 ), DR( 1, 8 ), DR( 1, 9 ),
01787      $                      DR( 1, 10 ), A( 1, 2 ), NMAX, A( 1, 3 ),
01788      $                      DC( 1, 1 ), A( 1, 4 ), WORK, LWORK, RWORK,
01789      $                      LWORK, IWORK, LIWORK, RESULT, INFO )
01790                IF( INFO.NE.0 )
01791      $            WRITE( NOUT, FMT = 9980 )'CDRVST', INFO
01792             END IF
01793   290    CONTINUE
01794 *
01795       ELSE IF( LSAMEN( 3, C3, 'CSG' ) ) THEN
01796 *
01797 *        ----------------------------------------------
01798 *        CSG:  Hermitian Generalized Eigenvalue Problem
01799 *        ----------------------------------------------
01800 *        Vary the parameters
01801 *           NB    = block size
01802 *           NBMIN = minimum block size
01803 *           NX    = crossover point
01804 *
01805          MAXTYP = 21
01806          NTYPES = MIN( MAXTYP, NTYPES )
01807          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01808          CALL XLAENV( 9, 25 )
01809          DO 310 I = 1, NPARMS
01810             CALL XLAENV( 1, NBVAL( I ) )
01811             CALL XLAENV( 2, NBMIN( I ) )
01812             CALL XLAENV( 3, NXVAL( I ) )
01813 *
01814             IF( NEWSD.EQ.0 ) THEN
01815                DO 300 K = 1, 4
01816                   ISEED( K ) = IOLDSD( K )
01817   300          CONTINUE
01818             END IF
01819             WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ),
01820      $         NXVAL( I )
01821             IF( TSTCHK ) THEN
01822                CALL CDRVSG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
01823      $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
01824      $                      DR( 1, 3 ), A( 1, 3 ), NMAX, A( 1, 4 ),
01825      $                      A( 1, 5 ), A( 1, 6 ), A( 1, 7 ), WORK,
01826      $                      LWORK, RWORK, LWORK, IWORK, LIWORK, RESULT,
01827      $                      INFO )
01828                IF( INFO.NE.0 )
01829      $            WRITE( NOUT, FMT = 9980 )'CDRVSG', INFO
01830             END IF
01831   310    CONTINUE
01832 *
01833       ELSE IF( LSAMEN( 3, C3, 'CBD' ) .OR. LSAMEN( 3, C3, 'SVD' ) ) THEN
01834 *
01835 *        ----------------------------------
01836 *        SVD:  Singular Value Decomposition
01837 *        ----------------------------------
01838 *        Vary the parameters
01839 *           NB    = block size
01840 *           NBMIN = minimum block size
01841 *           NX    = crossover point
01842 *           NRHS  = number of right hand sides
01843 *
01844          MAXTYP = 16
01845          NTYPES = MIN( MAXTYP, NTYPES )
01846          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01847          CALL XLAENV( 9, 25 )
01848 *
01849 *        Test the error exits
01850 *
01851          CALL XLAENV( 1, 1 )
01852          IF( TSTERR .AND. TSTCHK )
01853      $      CALL CERRBD( 'CBD', NOUT )
01854          IF( TSTERR .AND. TSTDRV )
01855      $      CALL CERRED( 'CBD', NOUT )
01856 *
01857          DO 330 I = 1, NPARMS
01858             NRHS = NSVAL( I )
01859             CALL XLAENV( 1, NBVAL( I ) )
01860             CALL XLAENV( 2, NBMIN( I ) )
01861             CALL XLAENV( 3, NXVAL( I ) )
01862             IF( NEWSD.EQ.0 ) THEN
01863                DO 320 K = 1, 4
01864                   ISEED( K ) = IOLDSD( K )
01865   320          CONTINUE
01866             END IF
01867             WRITE( NOUT, FMT = 9995 )C3, NBVAL( I ), NBMIN( I ),
01868      $         NXVAL( I ), NRHS
01869             IF( TSTCHK ) THEN
01870                CALL CCHKBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, NRHS, ISEED,
01871      $                      THRESH, A( 1, 1 ), NMAX, DR( 1, 1 ),
01872      $                      DR( 1, 2 ), DR( 1, 3 ), DR( 1, 4 ),
01873      $                      A( 1, 2 ), NMAX, A( 1, 3 ), A( 1, 4 ),
01874      $                      A( 1, 5 ), NMAX, A( 1, 6 ), NMAX, A( 1, 7 ),
01875      $                      A( 1, 8 ), WORK, LWORK, RWORK, NOUT, INFO )
01876                IF( INFO.NE.0 )
01877      $            WRITE( NOUT, FMT = 9980 )'CCHKBD', INFO
01878             END IF
01879             IF( TSTDRV )
01880      $         CALL CDRVBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, ISEED,
01881      $                      THRESH, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
01882      $                      A( 1, 3 ), NMAX, A( 1, 4 ), A( 1, 5 ),
01883      $                      A( 1, 6 ), DR( 1, 1 ), DR( 1, 2 ),
01884      $                      DR( 1, 3 ), WORK, LWORK, RWORK, IWORK, NOUT,
01885      $                      INFO )
01886   330    CONTINUE
01887 *
01888       ELSE IF( LSAMEN( 3, C3, 'CEV' ) ) THEN
01889 *
01890 *        --------------------------------------------
01891 *        CEV:  Nonsymmetric Eigenvalue Problem Driver
01892 *              CGEEV (eigenvalues and eigenvectors)
01893 *        --------------------------------------------
01894 *
01895          MAXTYP = 21
01896          NTYPES = MIN( MAXTYP, NTYPES )
01897          IF( NTYPES.LE.0 ) THEN
01898             WRITE( NOUT, FMT = 9990 )C3
01899          ELSE
01900             IF( TSTERR )
01901      $         CALL CERRED( C3, NOUT )
01902             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01903             CALL CDRVEV( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT,
01904      $                   A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ),
01905      $                   DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX,
01906      $                   A( 1, 5 ), NMAX, RESULT, WORK, LWORK, RWORK,
01907      $                   IWORK, INFO )
01908             IF( INFO.NE.0 )
01909      $         WRITE( NOUT, FMT = 9980 )'CGEEV', INFO
01910          END IF
01911          WRITE( NOUT, FMT = 9973 )
01912          GO TO 10
01913 *
01914       ELSE IF( LSAMEN( 3, C3, 'CES' ) ) THEN
01915 *
01916 *        --------------------------------------------
01917 *        CES:  Nonsymmetric Eigenvalue Problem Driver
01918 *              CGEES (Schur form)
01919 *        --------------------------------------------
01920 *
01921          MAXTYP = 21
01922          NTYPES = MIN( MAXTYP, NTYPES )
01923          IF( NTYPES.LE.0 ) THEN
01924             WRITE( NOUT, FMT = 9990 )C3
01925          ELSE
01926             IF( TSTERR )
01927      $         CALL CERRED( C3, NOUT )
01928             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01929             CALL CDRVES( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT,
01930      $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
01931      $                   DC( 1, 1 ), DC( 1, 2 ), A( 1, 4 ), NMAX,
01932      $                   RESULT, WORK, LWORK, RWORK, IWORK, LOGWRK,
01933      $                   INFO )
01934             IF( INFO.NE.0 )
01935      $         WRITE( NOUT, FMT = 9980 )'CGEES', INFO
01936          END IF
01937          WRITE( NOUT, FMT = 9973 )
01938          GO TO 10
01939 *
01940       ELSE IF( LSAMEN( 3, C3, 'CVX' ) ) THEN
01941 *
01942 *        --------------------------------------------------------------
01943 *        CVX:  Nonsymmetric Eigenvalue Problem Expert Driver
01944 *              CGEEVX (eigenvalues, eigenvectors and condition numbers)
01945 *        --------------------------------------------------------------
01946 *
01947          MAXTYP = 21
01948          NTYPES = MIN( MAXTYP, NTYPES )
01949          IF( NTYPES.LT.0 ) THEN
01950             WRITE( NOUT, FMT = 9990 )C3
01951          ELSE
01952             IF( TSTERR )
01953      $         CALL CERRED( C3, NOUT )
01954             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01955             CALL CDRVVX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN,
01956      $                   NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ),
01957      $                   DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX,
01958      $                   A( 1, 5 ), NMAX, DR( 1, 1 ), DR( 1, 2 ),
01959      $                   DR( 1, 3 ), DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
01960      $                   DR( 1, 7 ), DR( 1, 8 ), RESULT, WORK, LWORK,
01961      $                   RWORK, INFO )
01962             IF( INFO.NE.0 )
01963      $         WRITE( NOUT, FMT = 9980 )'CGEEVX', INFO
01964          END IF
01965          WRITE( NOUT, FMT = 9973 )
01966          GO TO 10
01967 *
01968       ELSE IF( LSAMEN( 3, C3, 'CSX' ) ) THEN
01969 *
01970 *        ---------------------------------------------------
01971 *        CSX:  Nonsymmetric Eigenvalue Problem Expert Driver
01972 *              CGEESX (Schur form and condition numbers)
01973 *        ---------------------------------------------------
01974 *
01975          MAXTYP = 21
01976          NTYPES = MIN( MAXTYP, NTYPES )
01977          IF( NTYPES.LT.0 ) THEN
01978             WRITE( NOUT, FMT = 9990 )C3
01979          ELSE
01980             IF( TSTERR )
01981      $         CALL CERRED( C3, NOUT )
01982             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
01983             CALL CDRVSX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN,
01984      $                   NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
01985      $                   DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), A( 1, 4 ),
01986      $                   NMAX, A( 1, 5 ), RESULT, WORK, LWORK, RWORK,
01987      $                   LOGWRK, INFO )
01988             IF( INFO.NE.0 )
01989      $         WRITE( NOUT, FMT = 9980 )'CGEESX', INFO
01990          END IF
01991          WRITE( NOUT, FMT = 9973 )
01992          GO TO 10
01993 *
01994       ELSE IF( LSAMEN( 3, C3, 'CGG' ) ) THEN
01995 *
01996 *        -------------------------------------------------
01997 *        CGG:  Generalized Nonsymmetric Eigenvalue Problem
01998 *        -------------------------------------------------
01999 *        Vary the parameters
02000 *           NB    = block size
02001 *           NBMIN = minimum block size
02002 *           NS    = number of shifts
02003 *           MAXB  = minimum submatrix size
02004 *           NBCOL = minimum column dimension for blocks
02005 *
02006          MAXTYP = 26
02007          NTYPES = MIN( MAXTYP, NTYPES )
02008          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02009          IF( TSTCHK .AND. TSTERR )
02010      $      CALL CERRGG( C3, NOUT )
02011          DO 350 I = 1, NPARMS
02012             CALL XLAENV( 1, NBVAL( I ) )
02013             CALL XLAENV( 2, NBMIN( I ) )
02014             CALL XLAENV( 4, NSVAL( I ) )
02015             CALL XLAENV( 8, MXBVAL( I ) )
02016             CALL XLAENV( 5, NBCOL( I ) )
02017 *
02018             IF( NEWSD.EQ.0 ) THEN
02019                DO 340 K = 1, 4
02020                   ISEED( K ) = IOLDSD( K )
02021   340          CONTINUE
02022             END IF
02023             WRITE( NOUT, FMT = 9996 )C3, NBVAL( I ), NBMIN( I ),
02024      $         NSVAL( I ), MXBVAL( I ), NBCOL( I )
02025             TSTDIF = .FALSE.
02026             THRSHN = 10.
02027             IF( TSTCHK ) THEN
02028                CALL CCHKGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
02029      $                      TSTDIF, THRSHN, NOUT, A( 1, 1 ), NMAX,
02030      $                      A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
02031      $                      A( 1, 6 ), A( 1, 7 ), A( 1, 8 ), A( 1, 9 ),
02032      $                      NMAX, A( 1, 10 ), A( 1, 11 ), A( 1, 12 ),
02033      $                      DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ),
02034      $                      DC( 1, 4 ), A( 1, 13 ), A( 1, 14 ), WORK,
02035      $                      LWORK, RWORK, LOGWRK, RESULT, INFO )
02036                IF( INFO.NE.0 )
02037      $            WRITE( NOUT, FMT = 9980 )'CCHKGG', INFO
02038             END IF
02039             CALL XLAENV( 1, 1 )
02040             IF( TSTDRV ) THEN
02041                CALL CDRVGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
02042      $                      THRSHN, NOUT, A( 1, 1 ), NMAX, A( 1, 2 ),
02043      $                      A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), A( 1, 6 ),
02044      $                      A( 1, 7 ), NMAX, A( 1, 8 ), DC( 1, 1 ),
02045      $                      DC( 1, 2 ), DC( 1, 3 ), DC( 1, 4 ),
02046      $                      A( 1, 8 ), A( 1, 9 ), WORK, LWORK, RWORK,
02047      $                      RESULT, INFO )
02048                IF( INFO.NE.0 )
02049      $            WRITE( NOUT, FMT = 9980 )'CDRVGG', INFO
02050             END IF
02051   350    CONTINUE
02052 *
02053       ELSE IF( LSAMEN( 3, C3, 'CGS' ) ) THEN
02054 *
02055 *        -------------------------------------------------
02056 *        CGS:  Generalized Nonsymmetric Eigenvalue Problem
02057 *              CGGES (Schur form)
02058 *        -------------------------------------------------
02059 *
02060          MAXTYP = 26
02061          NTYPES = MIN( MAXTYP, NTYPES )
02062          IF( NTYPES.LE.0 ) THEN
02063             WRITE( NOUT, FMT = 9990 )C3
02064          ELSE
02065             IF( TSTERR )
02066      $         CALL CERRGG( C3, NOUT )
02067             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02068             CALL CDRGES( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
02069      $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
02070      $                   A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
02071      $                   DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK,
02072      $                   RESULT, LOGWRK, INFO )
02073 *
02074             IF( INFO.NE.0 )
02075      $         WRITE( NOUT, FMT = 9980 )'CDRGES', INFO
02076          END IF
02077          WRITE( NOUT, FMT = 9973 )
02078          GO TO 10
02079 *
02080       ELSE IF( CGX ) THEN
02081 *
02082 *        -------------------------------------------------
02083 *        CGX  Generalized Nonsymmetric Eigenvalue Problem
02084 *              CGGESX (Schur form and condition numbers)
02085 *        -------------------------------------------------
02086 *
02087          MAXTYP = 5
02088          NTYPES = MAXTYP
02089          IF( NN.LT.0 ) THEN
02090             WRITE( NOUT, FMT = 9990 )C3
02091          ELSE
02092             IF( TSTERR )
02093      $         CALL CERRGG( C3, NOUT )
02094             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02095             CALL XLAENV( 5, 2 )
02096             CALL CDRGSX( NN, NCMAX, THRESH, NIN, NOUT, A( 1, 1 ), NMAX,
02097      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
02098      $                   A( 1, 6 ), DC( 1, 1 ), DC( 1, 2 ), C,
02099      $                   NCMAX*NCMAX, S, WORK, LWORK, RWORK, IWORK,
02100      $                   LIWORK, LOGWRK, INFO )
02101             IF( INFO.NE.0 )
02102      $         WRITE( NOUT, FMT = 9980 )'CDRGSX', INFO
02103          END IF
02104          WRITE( NOUT, FMT = 9973 )
02105          GO TO 10
02106 *
02107       ELSE IF( LSAMEN( 3, C3, 'CGV' ) ) THEN
02108 *
02109 *        -------------------------------------------------
02110 *        CGV:  Generalized Nonsymmetric Eigenvalue Problem
02111 *              CGGEV (Eigenvalue/vector form)
02112 *        -------------------------------------------------
02113 *
02114          MAXTYP = 26
02115          NTYPES = MIN( MAXTYP, NTYPES )
02116          IF( NTYPES.LE.0 ) THEN
02117             WRITE( NOUT, FMT = 9990 )C3
02118          ELSE
02119             IF( TSTERR )
02120      $         CALL CERRGG( C3, NOUT )
02121             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02122             CALL CDRGEV( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
02123      $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
02124      $                   A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
02125      $                   A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ),
02126      $                   DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK,
02127      $                   RESULT, INFO )
02128             IF( INFO.NE.0 )
02129      $         WRITE( NOUT, FMT = 9980 )'CDRGEV', INFO
02130          END IF
02131          WRITE( NOUT, FMT = 9973 )
02132          GO TO 10
02133 *
02134       ELSE IF( CXV ) THEN
02135 *
02136 *        -------------------------------------------------
02137 *        CXV:  Generalized Nonsymmetric Eigenvalue Problem
02138 *              CGGEVX (eigenvalue/vector with condition numbers)
02139 *        -------------------------------------------------
02140 *
02141          MAXTYP = 2
02142          NTYPES = MAXTYP
02143          IF( NN.LT.0 ) THEN
02144             WRITE( NOUT, FMT = 9990 )C3
02145          ELSE
02146             IF( TSTERR )
02147      $         CALL CERRGG( C3, NOUT )
02148             CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02149             CALL CDRGVX( NN, THRESH, NIN, NOUT, A( 1, 1 ), NMAX,
02150      $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), DC( 1, 1 ),
02151      $                   DC( 1, 2 ), A( 1, 5 ), A( 1, 6 ), IWORK( 1 ),
02152      $                   IWORK( 2 ), DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
02153      $                   DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), WORK,
02154      $                   LWORK, RWORK, IWORK( 3 ), LIWORK-2, RESULT,
02155      $                   LOGWRK, INFO )
02156 *
02157             IF( INFO.NE.0 )
02158      $         WRITE( NOUT, FMT = 9980 )'CDRGVX', INFO
02159          END IF
02160          WRITE( NOUT, FMT = 9973 )
02161          GO TO 10
02162 *
02163       ELSE IF( LSAMEN( 3, C3, 'CHB' ) ) THEN
02164 *
02165 *        ------------------------------
02166 *        CHB:  Hermitian Band Reduction
02167 *        ------------------------------
02168 *
02169          MAXTYP = 15
02170          NTYPES = MIN( MAXTYP, NTYPES )
02171          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02172          IF( TSTERR )
02173      $      CALL CERRST( 'CHB', NOUT )
02174          CALL CCHKHB( NN, NVAL, NK, KVAL, MAXTYP, DOTYPE, ISEED, THRESH,
02175      $                NOUT, A( 1, 1 ), NMAX, DR( 1, 1 ), DR( 1, 2 ),
02176      $                A( 1, 2 ), NMAX, WORK, LWORK, RWORK, RESULT,
02177      $                INFO )
02178          IF( INFO.NE.0 )
02179      $      WRITE( NOUT, FMT = 9980 )'CCHKHB', INFO
02180 *
02181       ELSE IF( LSAMEN( 3, C3, 'CBB' ) ) THEN
02182 *
02183 *        ------------------------------
02184 *        CBB:  General Band Reduction
02185 *        ------------------------------
02186 *
02187          MAXTYP = 15
02188          NTYPES = MIN( MAXTYP, NTYPES )
02189          CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
02190          DO 370 I = 1, NPARMS
02191             NRHS = NSVAL( I )
02192 *
02193             IF( NEWSD.EQ.0 ) THEN
02194                DO 360 K = 1, 4
02195                   ISEED( K ) = IOLDSD( K )
02196   360          CONTINUE
02197             END IF
02198             WRITE( NOUT, FMT = 9966 )C3, NRHS
02199             CALL CCHKBB( NN, MVAL, NVAL, NK, KVAL, MAXTYP, DOTYPE, NRHS,
02200      $                   ISEED, THRESH, NOUT, A( 1, 1 ), NMAX,
02201      $                   A( 1, 2 ), 2*NMAX, DR( 1, 1 ), DR( 1, 2 ),
02202      $                   A( 1, 4 ), NMAX, A( 1, 5 ), NMAX, A( 1, 6 ),
02203      $                   NMAX, A( 1, 7 ), WORK, LWORK, RWORK, RESULT,
02204      $                   INFO )
02205             IF( INFO.NE.0 )
02206      $         WRITE( NOUT, FMT = 9980 )'CCHKBB', INFO
02207   370    CONTINUE
02208 *
02209       ELSE IF( LSAMEN( 3, C3, 'GLM' ) ) THEN
02210 *
02211 *        -----------------------------------------
02212 *        GLM:  Generalized Linear Regression Model
02213 *        -----------------------------------------
02214 *
02215          CALL XLAENV( 1, 1 )
02216          IF( TSTERR )
02217      $      CALL CERRGG( 'GLM', NOUT )
02218          CALL CCKGLM( NN, NVAL, MVAL, PVAL, NTYPES, ISEED, THRESH, NMAX,
02219      $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X,
02220      $                WORK, DR( 1, 1 ), NIN, NOUT, INFO )
02221          IF( INFO.NE.0 )
02222      $      WRITE( NOUT, FMT = 9980 )'CCKGLM', INFO
02223 *
02224       ELSE IF( LSAMEN( 3, C3, 'GQR' ) ) THEN
02225 *
02226 *        ------------------------------------------
02227 *        GQR:  Generalized QR and RQ factorizations
02228 *        ------------------------------------------
02229 *
02230          CALL XLAENV( 1, 1 )
02231          IF( TSTERR )
02232      $      CALL CERRGG( 'GQR', NOUT )
02233          CALL CCKGQR( NN, MVAL, NN, PVAL, NN, NVAL, NTYPES, ISEED,
02234      $                THRESH, NMAX, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
02235      $                A( 1, 4 ), TAUA, B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
02236      $                B( 1, 4 ), B( 1, 5 ), TAUB, WORK, DR( 1, 1 ), NIN,
02237      $                NOUT, INFO )
02238          IF( INFO.NE.0 )
02239      $      WRITE( NOUT, FMT = 9980 )'CCKGQR', INFO
02240 *
02241       ELSE IF( LSAMEN( 3, C3, 'GSV' ) ) THEN
02242 *
02243 *        ----------------------------------------------
02244 *        GSV:  Generalized Singular Value Decomposition
02245 *        ----------------------------------------------
02246 *
02247          IF( TSTERR )
02248      $      CALL CERRGG( 'GSV', NOUT )
02249          CALL CCKGSV( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
02250      $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
02251      $                A( 1, 3 ), B( 1, 3 ), A( 1, 4 ), ALPHA, BETA,
02252      $                B( 1, 4 ), IWORK, WORK, DR( 1, 1 ), NIN, NOUT,
02253      $                INFO )
02254          IF( INFO.NE.0 )
02255      $      WRITE( NOUT, FMT = 9980 )'CCKGSV', INFO
02256 *
02257       ELSE IF( LSAMEN( 3, C3, 'LSE' ) ) THEN
02258 *
02259 *        --------------------------------------
02260 *        LSE:  Constrained Linear Least Squares
02261 *        --------------------------------------
02262 *
02263          CALL XLAENV( 1, 1 )
02264          IF( TSTERR )
02265      $      CALL CERRGG( 'LSE', NOUT )
02266          CALL CCKLSE( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
02267      $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X,
02268      $                WORK, DR( 1, 1 ), NIN, NOUT, INFO )
02269          IF( INFO.NE.0 )
02270      $      WRITE( NOUT, FMT = 9980 )'CCKLSE', INFO
02271       ELSE
02272          WRITE( NOUT, FMT = * )
02273          WRITE( NOUT, FMT = * )
02274          WRITE( NOUT, FMT = 9992 )C3
02275       END IF
02276       IF( .NOT.( CGX .OR. CXV ) )
02277      $   GO TO 190
02278   380 CONTINUE
02279       WRITE( NOUT, FMT = 9994 )
02280       S2 = SECOND( )
02281       WRITE( NOUT, FMT = 9993 )S2 - S1
02282 *
02283  9999 FORMAT( / ' Execution not attempted due to input errors' )
02284  9998 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
02285      $      ', NS =', I4, ', MAXB =', I4 )
02286  9997 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4 )
02287  9996 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NS =', I4,
02288      $      ', MAXB =', I4, ', NBCOL =', I4 )
02289  9995 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
02290      $      ', NRHS =', I4 )
02291  9994 FORMAT( / / ' End of tests' )
02292  9993 FORMAT( ' Total time used = ', F12.2, ' seconds', / )
02293  9992 FORMAT( 1X, A3, ':  Unrecognized path name' )
02294  9991 FORMAT( / / ' *** Invalid integer value in column ', I2,
02295      $      ' of input', ' line:', / A79 )
02296  9990 FORMAT( / / 1X, A3, ' routines were not tested' )
02297  9989 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be >=',
02298      $      I6 )
02299  9988 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be <=',
02300      $      I6 )
02301  9987 FORMAT( ' Tests of the Nonsymmetric Eigenvalue Problem routines' )
02302  9986 FORMAT( ' Tests of the Hermitian Eigenvalue Problem routines' )
02303  9985 FORMAT( ' Tests of the Singular Value Decomposition routines' )
02304  9984 FORMAT( / ' The following parameter values will be used:' )
02305  9983 FORMAT( 4X, A, 10I6, / 10X, 10I6 )
02306  9982 FORMAT( / ' Routines pass computational tests if test ratio is ',
02307      $      'less than', F8.2, / )
02308  9981 FORMAT( ' Relative machine ', A, ' is taken to be', E16.6 )
02309  9980 FORMAT( ' *** Error code from ', A, ' = ', I4 )
02310  9979 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver',
02311      $      / '    CGEEV (eigenvalues and eigevectors)' )
02312  9978 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver',
02313      $      / '    CGEES (Schur form)' )
02314  9977 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert',
02315      $      ' Driver', / '    CGEEVX (eigenvalues, eigenvectors and',
02316      $      ' condition numbers)' )
02317  9976 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert',
02318      $      ' Driver', / '    CGEESX (Schur form and condition',
02319      $      ' numbers)' )
02320  9975 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
02321      $      'Problem routines' )
02322  9974 FORMAT( ' Tests of CHBTRD', / ' (reduction of a Hermitian band ',
02323      $      'matrix to real tridiagonal form)' )
02324  9973 FORMAT( / 1X, 71( '-' ) )
02325  9972 FORMAT( / ' LAPACK VERSION ', I1, '.', I1, '.', I1 )
02326  9971 FORMAT( / ' Tests of the Generalized Linear Regression Model ',
02327      $      'routines' )
02328  9970 FORMAT( / ' Tests of the Generalized QR and RQ routines' )
02329  9969 FORMAT( / ' Tests of the Generalized Singular Value',
02330      $      ' Decomposition routines' )
02331  9968 FORMAT( / ' Tests of the Linear Least Squares routines' )
02332  9967 FORMAT( ' Tests of CGBBRD', / ' (reduction of a general band ',
02333      $      'matrix to real bidiagonal form)' )
02334  9966 FORMAT( / / 1X, A3, ':  NRHS =', I4 )
02335  9965 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
02336      $      'Problem Expert Driver CGGESX' )
02337  9964 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
02338      $      'Problem Driver CGGES' )
02339  9963 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
02340      $      'Problem Driver CGGEV' )
02341  9962 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
02342      $      'Problem Expert Driver CGGEVX' )
02343  9961 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
02344      $      ', INMIN=', I4, 
02345      $      ', INWIN =', I4, ', INIBL =', I4, ', ISHFTS =', I4,
02346      $      ', IACC22 =', I4)
02347 *
02348 *     End of CCHKEE
02349 *
02350       END