LAPACK: TESTING/EIG/zchkee.f Source File

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