LAPACK: TESTING/EIG/dchkee.f Source File

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