LAPACK: TESTING/EIG/dchkee.f Source File

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