1*> \brief \b CCHKEE
2*
3*  =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6*            http://www.netlib.org/lapack/explore-html/
7*
8*  Definition:
9*  ===========
10*
11*       PROGRAM CCHKEE
12*
13*
14*> \par Purpose:
15*  =============
16*>
17*> \verbatim
18*>
19*> CCHKEE tests the COMPLEX LAPACK subroutines for the matrix
20*> eigenvalue problem.  The test paths in this version are
21*>
22*> NEP (Nonsymmetric Eigenvalue Problem):
23*>     Test CGEHRD, CUNGHR, CHSEQR, CTREVC, CHSEIN, and CUNMHR
24*>
25*> SEP (Hermitian Eigenvalue Problem):
26*>     Test CHETRD, CUNGTR, CSTEQR, CSTERF, CSTEIN, CSTEDC,
27*>     and drivers CHEEV(X), CHBEV(X), CHPEV(X),
28*>                 CHEEVD,   CHBEVD,   CHPEVD
29*>
30*> SVD (Singular Value Decomposition):
31*>     Test CGEBRD, CUNGBR, and CBDSQR
32*>     and the drivers CGESVD, CGESDD
33*>
34*> CEV (Nonsymmetric Eigenvalue/eigenvector Driver):
35*>     Test CGEEV
36*>
37*> CES (Nonsymmetric Schur form Driver):
38*>     Test CGEES
39*>
40*> CVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver):
41*>     Test CGEEVX
42*>
43*> CSX (Nonsymmetric Schur form Expert Driver):
44*>     Test CGEESX
45*>
46*> CGG (Generalized Nonsymmetric Eigenvalue Problem):
47*>     Test CGGHD3, CGGBAL, CGGBAK, CHGEQZ, and CTGEVC
48*>
49*> CGS (Generalized Nonsymmetric Schur form Driver):
50*>     Test CGGES
51*>
52*> CGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver):
53*>     Test CGGEV
54*>
55*> CGX (Generalized Nonsymmetric Schur form Expert Driver):
56*>     Test CGGESX
57*>
58*> CXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):
59*>     Test CGGEVX
60*>
61*> CSG (Hermitian Generalized Eigenvalue Problem):
62*>     Test CHEGST, CHEGV, CHEGVD, CHEGVX, CHPGST, CHPGV, CHPGVD,
63*>     CHPGVX, CHBGST, CHBGV, CHBGVD, and CHBGVX
64*>
65*> CHB (Hermitian Band Eigenvalue Problem):
66*>     Test CHBTRD
67*>
68*> CBB (Band Singular Value Decomposition):
69*>     Test CGBBRD
70*>
71*> CEC (Eigencondition estimation):
72*>     Test CTRSYL, CTREXC, CTRSNA, and CTRSEN
73*>
74*> CBL (Balancing a general matrix)
75*>     Test CGEBAL
76*>
77*> CBK (Back transformation on a balanced matrix)
78*>     Test CGEBAK
79*>
80*> CGL (Balancing a matrix pair)
81*>     Test CGGBAL
82*>
83*> CGK (Back transformation on a matrix pair)
84*>     Test CGGBAK
85*>
86*> GLM (Generalized Linear Regression Model):
87*>     Tests CGGGLM
88*>
89*> GQR (Generalized QR and RQ factorizations):
90*>     Tests CGGQRF and CGGRQF
91*>
92*> GSV (Generalized Singular Value Decomposition):
93*>     Tests CGGSVD, CGGSVP, CTGSJA, CLAGS2, CLAPLL, and CLAPMT
94*>
95*> CSD (CS decomposition):
96*>     Tests CUNCSD
97*>
98*> LSE (Constrained Linear Least Squares):
99*>     Tests CGGLSE
100*>
101*> Each test path has a different set of inputs, but the data sets for
102*> the driver routines xEV, xES, xVX, and xSX can be concatenated in a
103*> single input file.  The first line of input should contain one of the
104*> 3-character path names in columns 1-3.  The number of remaining lines
105*> depends on what is found on the first line.
106*>
107*> The number of matrix types used in testing is often controllable from
108*> the input file.  The number of matrix types for each path, and the
109*> test routine that describes them, is as follows:
110*>
111*> Path name(s)  Types    Test routine
112*>
113*> CHS or NEP      21     CCHKHS
114*> CST or SEP      21     CCHKST (routines)
115*>                 18     CDRVST (drivers)
116*> CBD or SVD      16     CCHKBD (routines)
117*>                  5     CDRVBD (drivers)
118*> CEV             21     CDRVEV
119*> CES             21     CDRVES
120*> CVX             21     CDRVVX
121*> CSX             21     CDRVSX
122*> CGG             26     CCHKGG (routines)
123*> CGS             26     CDRGES
124*> CGX              5     CDRGSX
125*> CGV             26     CDRGEV
126*> CXV              2     CDRGVX
127*> CSG             21     CDRVSG
128*> CHB             15     CCHKHB
129*> CBB             15     CCHKBB
130*> CEC              -     CCHKEC
131*> CBL              -     CCHKBL
132*> CBK              -     CCHKBK
133*> CGL              -     CCHKGL
134*> CGK              -     CCHKGK
135*> GLM              8     CCKGLM
136*> GQR              8     CCKGQR
137*> GSV              8     CCKGSV
138*> CSD              3     CCKCSD
139*> LSE              8     CCKLSE
140*>
141*>-----------------------------------------------------------------------
142*>
143*> NEP input file:
144*>
145*> line 2:  NN, INTEGER
146*>          Number of values of N.
147*>
148*> line 3:  NVAL, INTEGER array, dimension (NN)
149*>          The values for the matrix dimension N.
150*>
151*> line 4:  NPARMS, INTEGER
152*>          Number of values of the parameters NB, NBMIN, NX, NS, and
153*>          MAXB.
154*>
155*> line 5:  NBVAL, INTEGER array, dimension (NPARMS)
156*>          The values for the blocksize NB.
157*>
158*> line 6:  NBMIN, INTEGER array, dimension (NPARMS)
159*>          The values for the minimum blocksize NBMIN.
160*>
161*> line 7:  NXVAL, INTEGER array, dimension (NPARMS)
162*>          The values for the crossover point NX.
163*>
164*> line 8:  INMIN, INTEGER array, dimension (NPARMS)
165*>          LAHQR vs TTQRE crossover point, >= 11
166*>
167*> line 9:  INWIN, INTEGER array, dimension (NPARMS)
168*>          recommended deflation window size
169*>
170*> line 10: INIBL, INTEGER array, dimension (NPARMS)
171*>          nibble crossover point
172*>
173*> line 11:  ISHFTS, INTEGER array, dimension (NPARMS)
174*>          number of simultaneous shifts)
175*>
176*> line 12:  IACC22, INTEGER array, dimension (NPARMS)
177*>          select structured matrix multiply: 0, 1 or 2)
178*>
179*> line 13: THRESH
180*>          Threshold value for the test ratios.  Information will be
181*>          printed about each test for which the test ratio is greater
182*>          than or equal to the threshold.  To have all of the test
183*>          ratios printed, use THRESH = 0.0 .
184*>
185*> line 14: NEWSD, INTEGER
186*>          A code indicating how to set the random number seed.
187*>          = 0:  Set the seed to a default value before each run
188*>          = 1:  Initialize the seed to a default value only before the
189*>                first run
190*>          = 2:  Like 1, but use the seed values on the next line
191*>
192*> If line 14 was 2:
193*>
194*> line 15: INTEGER array, dimension (4)
195*>          Four integer values for the random number seed.
196*>
197*> lines 15-EOF:  The remaining lines occur in sets of 1 or 2 and allow
198*>          the user to specify the matrix types.  Each line contains
199*>          a 3-character path name in columns 1-3, and the number
200*>          of matrix types must be the first nonblank item in columns
201*>          4-80.  If the number of matrix types is at least 1 but is
202*>          less than the maximum number of possible types, a second
203*>          line will be read to get the numbers of the matrix types to
204*>          be used.  For example,
205*> NEP 21
206*>          requests all of the matrix types for the nonsymmetric
207*>          eigenvalue problem, while
208*> NEP  4
209*> 9 10 11 12
210*>          requests only matrices of type 9, 10, 11, and 12.
211*>
212*>          The valid 3-character path names are 'NEP' or 'CHS' for the
213*>          nonsymmetric eigenvalue routines.
214*>
215*>-----------------------------------------------------------------------
216*>
217*> SEP or CSG input file:
218*>
219*> line 2:  NN, INTEGER
220*>          Number of values of N.
221*>
222*> line 3:  NVAL, INTEGER array, dimension (NN)
223*>          The values for the matrix dimension N.
224*>
225*> line 4:  NPARMS, INTEGER
226*>          Number of values of the parameters NB, NBMIN, and NX.
227*>
228*> line 5:  NBVAL, INTEGER array, dimension (NPARMS)
229*>          The values for the blocksize NB.
230*>
231*> line 6:  NBMIN, INTEGER array, dimension (NPARMS)
232*>          The values for the minimum blocksize NBMIN.
233*>
234*> line 7:  NXVAL, INTEGER array, dimension (NPARMS)
235*>          The values for the crossover point NX.
236*>
237*> line 8:  THRESH
238*>          Threshold value for the test ratios.  Information will be
239*>          printed about each test for which the test ratio is greater
240*>          than or equal to the threshold.
241*>
242*> line 9:  TSTCHK, LOGICAL
243*>          Flag indicating whether or not to test the LAPACK routines.
244*>
245*> line 10: TSTDRV, LOGICAL
246*>          Flag indicating whether or not to test the driver routines.
247*>
248*> line 11: TSTERR, LOGICAL
249*>          Flag indicating whether or not to test the error exits for
250*>          the LAPACK routines and driver routines.
251*>
252*> line 12: NEWSD, INTEGER
253*>          A code indicating how to set the random number seed.
254*>          = 0:  Set the seed to a default value before each run
255*>          = 1:  Initialize the seed to a default value only before the
256*>                first run
257*>          = 2:  Like 1, but use the seed values on the next line
258*>
259*> If line 12 was 2:
260*>
261*> line 13: INTEGER array, dimension (4)
262*>          Four integer values for the random number seed.
263*>
264*> lines 13-EOF:  Lines specifying matrix types, as for NEP.
265*>          The valid 3-character path names are 'SEP' or 'CST' for the
266*>          Hermitian eigenvalue routines and driver routines, and
267*>          'CSG' for the routines for the Hermitian generalized
268*>          eigenvalue problem.
269*>
270*>-----------------------------------------------------------------------
271*>
272*> SVD input file:
273*>
274*> line 2:  NN, INTEGER
275*>          Number of values of M and N.
276*>
277*> line 3:  MVAL, INTEGER array, dimension (NN)
278*>          The values for the matrix row dimension M.
279*>
280*> line 4:  NVAL, INTEGER array, dimension (NN)
281*>          The values for the matrix column dimension N.
282*>
283*> line 5:  NPARMS, INTEGER
284*>          Number of values of the parameter NB, NBMIN, NX, and NRHS.
285*>
286*> line 6:  NBVAL, INTEGER array, dimension (NPARMS)
287*>          The values for the blocksize NB.
288*>
289*> line 7:  NBMIN, INTEGER array, dimension (NPARMS)
290*>          The values for the minimum blocksize NBMIN.
291*>
292*> line 8:  NXVAL, INTEGER array, dimension (NPARMS)
293*>          The values for the crossover point NX.
294*>
295*> line 9:  NSVAL, INTEGER array, dimension (NPARMS)
296*>          The values for the number of right hand sides NRHS.
297*>
298*> line 10: THRESH
299*>          Threshold value for the test ratios.  Information will be
300*>          printed about each test for which the test ratio is greater
301*>          than or equal to the threshold.
302*>
303*> line 11: TSTCHK, LOGICAL
304*>          Flag indicating whether or not to test the LAPACK routines.
305*>
306*> line 12: TSTDRV, LOGICAL
307*>          Flag indicating whether or not to test the driver routines.
308*>
309*> line 13: TSTERR, LOGICAL
310*>          Flag indicating whether or not to test the error exits for
311*>          the LAPACK routines and driver routines.
312*>
313*> line 14: NEWSD, INTEGER
314*>          A code indicating how to set the random number seed.
315*>          = 0:  Set the seed to a default value before each run
316*>          = 1:  Initialize the seed to a default value only before the
317*>                first run
318*>          = 2:  Like 1, but use the seed values on the next line
319*>
320*> If line 14 was 2:
321*>
322*> line 15: INTEGER array, dimension (4)
323*>          Four integer values for the random number seed.
324*>
325*> lines 15-EOF:  Lines specifying matrix types, as for NEP.
326*>          The 3-character path names are 'SVD' or 'CBD' for both the
327*>          SVD routines and the SVD driver routines.
328*>
329*>-----------------------------------------------------------------------
330*>
331*> CEV and CES data files:
332*>
333*> line 1:  'CEV' or 'CES' in columns 1 to 3.
334*>
335*> line 2:  NSIZES, INTEGER
336*>          Number of sizes of matrices to use. Should be at least 0
337*>          and at most 20. If NSIZES = 0, no testing is done
338*>          (although the remaining  3 lines are still read).
339*>
340*> line 3:  NN, INTEGER array, dimension(NSIZES)
341*>          Dimensions of matrices to be tested.
342*>
343*> line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
344*>          These integer parameters determine how blocking is done
345*>          (see ILAENV for details)
346*>          NB     : block size
347*>          NBMIN  : minimum block size
348*>          NX     : minimum dimension for blocking
349*>          NS     : number of shifts in xHSEQR
350*>          NBCOL  : minimum column dimension for blocking
351*>
352*> line 5:  THRESH, REAL
353*>          The test threshold against which computed residuals are
354*>          compared. Should generally be in the range from 10. to 20.
355*>          If it is 0., all test case data will be printed.
356*>
357*> line 6:  NEWSD, INTEGER
358*>          A code indicating how to set the random number seed.
359*>          = 0:  Set the seed to a default value before each run
360*>          = 1:  Initialize the seed to a default value only before the
361*>                first run
362*>          = 2:  Like 1, but use the seed values on the next line
363*>
364*> If line 6 was 2:
365*>
366*> line 7:  INTEGER array, dimension (4)
367*>          Four integer values for the random number seed.
368*>
369*> lines 8 and following:  Lines specifying matrix types, as for NEP.
370*>          The 3-character path name is 'CEV' to test CGEEV, or
371*>          'CES' to test CGEES.
372*>
373*>-----------------------------------------------------------------------
374*>
375*> The CVX data has two parts. The first part is identical to CEV,
376*> and the second part consists of test matrices with precomputed
377*> solutions.
378*>
379*> line 1:  'CVX' in columns 1-3.
380*>
381*> line 2:  NSIZES, INTEGER
382*>          If NSIZES = 0, no testing of randomly generated examples
383*>          is done, but any precomputed examples are tested.
384*>
385*> line 3:  NN, INTEGER array, dimension(NSIZES)
386*>
387*> line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
388*>
389*> line 5:  THRESH, REAL
390*>
391*> line 6:  NEWSD, INTEGER
392*>
393*> If line 6 was 2:
394*>
395*> line 7:  INTEGER array, dimension (4)
396*>
397*> lines 8 and following: The first line contains 'CVX' in columns 1-3
398*>          followed by the number of matrix types, possibly with
399*>          a second line to specify certain matrix types.
400*>          If the number of matrix types = 0, no testing of randomly
401*>          generated examples is done, but any precomputed examples
402*>          are tested.
403*>
404*> remaining lines : Each matrix is stored on 1+N+N**2 lines, where N is
405*>          its dimension. The first line contains the dimension N and
406*>          ISRT (two integers). ISRT indicates whether the last N lines
407*>          are sorted by increasing real part of the eigenvalue
408*>          (ISRT=0) or by increasing imaginary part (ISRT=1). The next
409*>          N**2 lines contain the matrix rowwise, one entry per line.
410*>          The last N lines correspond to each eigenvalue. Each of
411*>          these last N lines contains 4 real values: the real part of
412*>          the eigenvalues, the imaginary part of the eigenvalue, the
413*>          reciprocal condition number of the eigenvalues, and the
414*>          reciprocal condition number of the vector eigenvector. The
415*>          end of data is indicated by dimension N=0. Even if no data
416*>          is to be tested, there must be at least one line containing
417*>          N=0.
418*>
419*>-----------------------------------------------------------------------
420*>
421*> The CSX data is like CVX. The first part is identical to CEV, and the
422*> second part consists of test matrices with precomputed solutions.
423*>
424*> line 1:  'CSX' in columns 1-3.
425*>
426*> line 2:  NSIZES, INTEGER
427*>          If NSIZES = 0, no testing of randomly generated examples
428*>          is done, but any precomputed examples are tested.
429*>
430*> line 3:  NN, INTEGER array, dimension(NSIZES)
431*>
432*> line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
433*>
434*> line 5:  THRESH, REAL
435*>
436*> line 6:  NEWSD, INTEGER
437*>
438*> If line 6 was 2:
439*>
440*> line 7:  INTEGER array, dimension (4)
441*>
442*> lines 8 and following: The first line contains 'CSX' in columns 1-3
443*>          followed by the number of matrix types, possibly with
444*>          a second line to specify certain matrix types.
445*>          If the number of matrix types = 0, no testing of randomly
446*>          generated examples is done, but any precomputed examples
447*>          are tested.
448*>
449*> remaining lines : Each matrix is stored on 3+N**2 lines, where N is
450*>          its dimension. The first line contains the dimension N, the
451*>          dimension M of an invariant subspace, and ISRT. The second
452*>          line contains M integers, identifying the eigenvalues in the
453*>          invariant subspace (by their position in a list of
454*>          eigenvalues ordered by increasing real part (if ISRT=0) or
455*>          by increasing imaginary part (if ISRT=1)). The next N**2
456*>          lines contain the matrix rowwise. The last line contains the
457*>          reciprocal condition number for the average of the selected
458*>          eigenvalues, and the reciprocal condition number for the
459*>          corresponding right invariant subspace. The end of data in
460*>          indicated by a line containing N=0, M=0, and ISRT = 0.  Even
461*>          if no data is to be tested, there must be at least one line
462*>          containing N=0, M=0 and ISRT=0.
463*>
464*>-----------------------------------------------------------------------
465*>
466*> CGG input file:
467*>
468*> line 2:  NN, INTEGER
469*>          Number of values of N.
470*>
471*> line 3:  NVAL, INTEGER array, dimension (NN)
472*>          The values for the matrix dimension N.
473*>
474*> line 4:  NPARMS, INTEGER
475*>          Number of values of the parameters NB, NBMIN, NBCOL, NS, and
476*>          MAXB.
477*>
478*> line 5:  NBVAL, INTEGER array, dimension (NPARMS)
479*>          The values for the blocksize NB.
480*>
481*> line 6:  NBMIN, INTEGER array, dimension (NPARMS)
482*>          The values for NBMIN, the minimum row dimension for blocks.
483*>
484*> line 7:  NSVAL, INTEGER array, dimension (NPARMS)
485*>          The values for the number of shifts.
486*>
487*> line 8:  MXBVAL, INTEGER array, dimension (NPARMS)
488*>          The values for MAXB, used in determining minimum blocksize.
489*>
490*> line 9:  IACC22, INTEGER array, dimension (NPARMS)
491*>          select structured matrix multiply: 1 or 2)
492*>
493*> line 10: NBCOL, INTEGER array, dimension (NPARMS)
494*>          The values for NBCOL, the minimum column dimension for
495*>          blocks.
496*>
497*> line 11: THRESH
498*>          Threshold value for the test ratios.  Information will be
499*>          printed about each test for which the test ratio is greater
500*>          than or equal to the threshold.
501*>
502*> line 12: TSTCHK, LOGICAL
503*>          Flag indicating whether or not to test the LAPACK routines.
504*>
505*> line 13: TSTDRV, LOGICAL
506*>          Flag indicating whether or not to test the driver routines.
507*>
508*> line 14: TSTERR, LOGICAL
509*>          Flag indicating whether or not to test the error exits for
510*>          the LAPACK routines and driver routines.
511*>
512*> line 15: NEWSD, INTEGER
513*>          A code indicating how to set the random number seed.
514*>          = 0:  Set the seed to a default value before each run
515*>          = 1:  Initialize the seed to a default value only before the
516*>                first run
517*>          = 2:  Like 1, but use the seed values on the next line
518*>
519*> If line 15 was 2:
520*>
521*> line 16: INTEGER array, dimension (4)
522*>          Four integer values for the random number seed.
523*>
524*> lines 17-EOF:  Lines specifying matrix types, as for NEP.
525*>          The 3-character path name is 'CGG' for the generalized
526*>          eigenvalue problem routines and driver routines.
527*>
528*>-----------------------------------------------------------------------
529*>
530*> CGS and CGV input files:
531*>
532*> line 1:  'CGS' or 'CGV' in columns 1 to 3.
533*>
534*> line 2:  NN, INTEGER
535*>          Number of values of N.
536*>
537*> line 3:  NVAL, INTEGER array, dimension(NN)
538*>          Dimensions of matrices to be tested.
539*>
540*> line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
541*>          These integer parameters determine how blocking is done
542*>          (see ILAENV for details)
543*>          NB     : block size
544*>          NBMIN  : minimum block size
545*>          NX     : minimum dimension for blocking
546*>          NS     : number of shifts in xHGEQR
547*>          NBCOL  : minimum column dimension for blocking
548*>
549*> line 5:  THRESH, REAL
550*>          The test threshold against which computed residuals are
551*>          compared. Should generally be in the range from 10. to 20.
552*>          If it is 0., all test case data will be printed.
553*>
554*> line 6:  TSTERR, LOGICAL
555*>          Flag indicating whether or not to test the error exits.
556*>
557*> line 7:  NEWSD, INTEGER
558*>          A code indicating how to set the random number seed.
559*>          = 0:  Set the seed to a default value before each run
560*>          = 1:  Initialize the seed to a default value only before the
561*>                first run
562*>          = 2:  Like 1, but use the seed values on the next line
563*>
564*> If line 17 was 2:
565*>
566*> line 7:  INTEGER array, dimension (4)
567*>          Four integer values for the random number seed.
568*>
569*> lines 7-EOF:  Lines specifying matrix types, as for NEP.
570*>          The 3-character path name is 'CGS' for the generalized
571*>          eigenvalue problem routines and driver routines.
572*>
573*>-----------------------------------------------------------------------
574*>
575*> CGX input file:
576*> line 1:  'CGX' in columns 1 to 3.
577*>
578*> line 2:  N, INTEGER
579*>          Value of N.
580*>
581*> line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
582*>          These integer parameters determine how blocking is done
583*>          (see ILAENV for details)
584*>          NB     : block size
585*>          NBMIN  : minimum block size
586*>          NX     : minimum dimension for blocking
587*>          NS     : number of shifts in xHGEQR
588*>          NBCOL  : minimum column dimension for blocking
589*>
590*> line 4:  THRESH, REAL
591*>          The test threshold against which computed residuals are
592*>          compared. Should generally be in the range from 10. to 20.
593*>          Information will be printed about each test for which the
594*>          test ratio is greater than or equal to the threshold.
595*>
596*> line 5:  TSTERR, LOGICAL
597*>          Flag indicating whether or not to test the error exits for
598*>          the LAPACK routines and driver routines.
599*>
600*> line 6:  NEWSD, INTEGER
601*>          A code indicating how to set the random number seed.
602*>          = 0:  Set the seed to a default value before each run
603*>          = 1:  Initialize the seed to a default value only before the
604*>                first run
605*>          = 2:  Like 1, but use the seed values on the next line
606*>
607*> If line 6 was 2:
608*>
609*> line 7: INTEGER array, dimension (4)
610*>          Four integer values for the random number seed.
611*>
612*> If line 2 was 0:
613*>
614*> line 7-EOF: Precomputed examples are tested.
615*>
616*> remaining lines : Each example is stored on 3+2*N*N lines, where N is
617*>          its dimension. The first line contains the dimension (a
618*>          single integer).  The next line contains an integer k such
619*>          that only the last k eigenvalues will be selected and appear
620*>          in the leading diagonal blocks of $A$ and $B$. The next N*N
621*>          lines contain the matrix A, one element per line. The next N*N
622*>          lines contain the matrix B. The last line contains the
623*>          reciprocal of the eigenvalue cluster condition number and the
624*>          reciprocal of the deflating subspace (associated with the
625*>          selected eigencluster) condition number.  The end of data is
626*>          indicated by dimension N=0.  Even if no data is to be tested,
627*>          there must be at least one line containing N=0.
628*>
629*>-----------------------------------------------------------------------
630*>
631*> CXV input files:
632*> line 1:  'CXV' in columns 1 to 3.
633*>
634*> line 2:  N, INTEGER
635*>          Value of N.
636*>
637*> line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
638*>          These integer parameters determine how blocking is done
639*>          (see ILAENV for details)
640*>          NB     : block size
641*>          NBMIN  : minimum block size
642*>          NX     : minimum dimension for blocking
643*>          NS     : number of shifts in xHGEQR
644*>          NBCOL  : minimum column dimension for blocking
645*>
646*> line 4:  THRESH, REAL
647*>          The test threshold against which computed residuals are
648*>          compared. Should generally be in the range from 10. to 20.
649*>          Information will be printed about each test for which the
650*>          test ratio is greater than or equal to the threshold.
651*>
652*> line 5:  TSTERR, LOGICAL
653*>          Flag indicating whether or not to test the error exits for
654*>          the LAPACK routines and driver routines.
655*>
656*> line 6:  NEWSD, INTEGER
657*>          A code indicating how to set the random number seed.
658*>          = 0:  Set the seed to a default value before each run
659*>          = 1:  Initialize the seed to a default value only before the
660*>                first run
661*>          = 2:  Like 1, but use the seed values on the next line
662*>
663*> If line 6 was 2:
664*>
665*> line 7: INTEGER array, dimension (4)
666*>          Four integer values for the random number seed.
667*>
668*> If line 2 was 0:
669*>
670*> line 7-EOF: Precomputed examples are tested.
671*>
672*> remaining lines : Each example is stored on 3+2*N*N lines, where N is
673*>          its dimension. The first line contains the dimension (a
674*>          single integer). The next N*N lines contain the matrix A, one
675*>          element per line. The next N*N lines contain the matrix B.
676*>          The next line contains the reciprocals of the eigenvalue
677*>          condition numbers.  The last line contains the reciprocals of
678*>          the eigenvector condition numbers.  The end of data is
679*>          indicated by dimension N=0.  Even if no data is to be tested,
680*>          there must be at least one line containing N=0.
681*>
682*>-----------------------------------------------------------------------
683*>
684*> CHB input file:
685*>
686*> line 2:  NN, INTEGER
687*>          Number of values of N.
688*>
689*> line 3:  NVAL, INTEGER array, dimension (NN)
690*>          The values for the matrix dimension N.
691*>
692*> line 4:  NK, INTEGER
693*>          Number of values of K.
694*>
695*> line 5:  KVAL, INTEGER array, dimension (NK)
696*>          The values for the matrix dimension K.
697*>
698*> line 6:  THRESH
699*>          Threshold value for the test ratios.  Information will be
700*>          printed about each test for which the test ratio is greater
701*>          than or equal to the threshold.
702*>
703*> line 7:  NEWSD, INTEGER
704*>          A code indicating how to set the random number seed.
705*>          = 0:  Set the seed to a default value before each run
706*>          = 1:  Initialize the seed to a default value only before the
707*>                first run
708*>          = 2:  Like 1, but use the seed values on the next line
709*>
710*> If line 7 was 2:
711*>
712*> line 8:  INTEGER array, dimension (4)
713*>          Four integer values for the random number seed.
714*>
715*> lines 8-EOF:  Lines specifying matrix types, as for NEP.
716*>          The 3-character path name is 'CHB'.
717*>
718*>-----------------------------------------------------------------------
719*>
720*> CBB input file:
721*>
722*> line 2:  NN, INTEGER
723*>          Number of values of M and N.
724*>
725*> line 3:  MVAL, INTEGER array, dimension (NN)
726*>          The values for the matrix row dimension M.
727*>
728*> line 4:  NVAL, INTEGER array, dimension (NN)
729*>          The values for the matrix column dimension N.
730*>
731*> line 4:  NK, INTEGER
732*>          Number of values of K.
733*>
734*> line 5:  KVAL, INTEGER array, dimension (NK)
735*>          The values for the matrix bandwidth K.
736*>
737*> line 6:  NPARMS, INTEGER
738*>          Number of values of the parameter NRHS
739*>
740*> line 7:  NSVAL, INTEGER array, dimension (NPARMS)
741*>          The values for the number of right hand sides NRHS.
742*>
743*> line 8:  THRESH
744*>          Threshold value for the test ratios.  Information will be
745*>          printed about each test for which the test ratio is greater
746*>          than or equal to the threshold.
747*>
748*> line 9:  NEWSD, INTEGER
749*>          A code indicating how to set the random number seed.
750*>          = 0:  Set the seed to a default value before each run
751*>          = 1:  Initialize the seed to a default value only before the
752*>                first run
753*>          = 2:  Like 1, but use the seed values on the next line
754*>
755*> If line 9 was 2:
756*>
757*> line 10: INTEGER array, dimension (4)
758*>          Four integer values for the random number seed.
759*>
760*> lines 10-EOF:  Lines specifying matrix types, as for SVD.
761*>          The 3-character path name is 'CBB'.
762*>
763*>-----------------------------------------------------------------------
764*>
765*> CEC input file:
766*>
767*> line  2: THRESH, REAL
768*>          Threshold value for the test ratios.  Information will be
769*>          printed about each test for which the test ratio is greater
770*>          than or equal to the threshold.
771*>
772*> lines  3-EOF:
773*>
774*> Input for testing the eigencondition routines consists of a set of
775*> specially constructed test cases and their solutions.  The data
776*> format is not intended to be modified by the user.
777*>
778*>-----------------------------------------------------------------------
779*>
780*> CBL and CBK input files:
781*>
782*> line 1:  'CBL' in columns 1-3 to test CGEBAL, or 'CBK' in
783*>          columns 1-3 to test CGEBAK.
784*>
785*> The remaining lines consist of specially constructed test cases.
786*>
787*>-----------------------------------------------------------------------
788*>
789*> CGL and CGK input files:
790*>
791*> line 1:  'CGL' in columns 1-3 to test CGGBAL, or 'CGK' in
792*>          columns 1-3 to test CGGBAK.
793*>
794*> The remaining lines consist of specially constructed test cases.
795*>
796*>-----------------------------------------------------------------------
797*>
798*> GLM data file:
799*>
800*> line 1:  'GLM' in columns 1 to 3.
801*>
802*> line 2:  NN, INTEGER
803*>          Number of values of M, P, and N.
804*>
805*> line 3:  MVAL, INTEGER array, dimension(NN)
806*>          Values of M (row dimension).
807*>
808*> line 4:  PVAL, INTEGER array, dimension(NN)
809*>          Values of P (row dimension).
810*>
811*> line 5:  NVAL, INTEGER array, dimension(NN)
812*>          Values of N (column dimension), note M <= N <= M+P.
813*>
814*> line 6:  THRESH, REAL
815*>          Threshold value for the test ratios.  Information will be
816*>          printed about each test for which the test ratio is greater
817*>          than or equal to the threshold.
818*>
819*> line 7:  TSTERR, LOGICAL
820*>          Flag indicating whether or not to test the error exits for
821*>          the LAPACK routines and driver routines.
822*>
823*> line 8:  NEWSD, INTEGER
824*>          A code indicating how to set the random number seed.
825*>          = 0:  Set the seed to a default value before each run
826*>          = 1:  Initialize the seed to a default value only before the
827*>                first run
828*>          = 2:  Like 1, but use the seed values on the next line
829*>
830*> If line 8 was 2:
831*>
832*> line 9:  INTEGER array, dimension (4)
833*>          Four integer values for the random number seed.
834*>
835*> lines 9-EOF:  Lines specifying matrix types, as for NEP.
836*>          The 3-character path name is 'GLM' for the generalized
837*>          linear regression model routines.
838*>
839*>-----------------------------------------------------------------------
840*>
841*> GQR data file:
842*>
843*> line 1:  'GQR' in columns 1 to 3.
844*>
845*> line 2:  NN, INTEGER
846*>          Number of values of M, P, and N.
847*>
848*> line 3:  MVAL, INTEGER array, dimension(NN)
849*>          Values of M.
850*>
851*> line 4:  PVAL, INTEGER array, dimension(NN)
852*>          Values of P.
853*>
854*> line 5:  NVAL, INTEGER array, dimension(NN)
855*>          Values of N.
856*>
857*> line 6:  THRESH, REAL
858*>          Threshold value for the test ratios.  Information will be
859*>          printed about each test for which the test ratio is greater
860*>          than or equal to the threshold.
861*>
862*> line 7:  TSTERR, LOGICAL
863*>          Flag indicating whether or not to test the error exits for
864*>          the LAPACK routines and driver routines.
865*>
866*> line 8:  NEWSD, INTEGER
867*>          A code indicating how to set the random number seed.
868*>          = 0:  Set the seed to a default value before each run
869*>          = 1:  Initialize the seed to a default value only before the
870*>                first run
871*>          = 2:  Like 1, but use the seed values on the next line
872*>
873*> If line 8 was 2:
874*>
875*> line 9:  INTEGER array, dimension (4)
876*>          Four integer values for the random number seed.
877*>
878*> lines 9-EOF:  Lines specifying matrix types, as for NEP.
879*>          The 3-character path name is 'GQR' for the generalized
880*>          QR and RQ routines.
881*>
882*>-----------------------------------------------------------------------
883*>
884*> GSV data file:
885*>
886*> line 1:  'GSV' in columns 1 to 3.
887*>
888*> line 2:  NN, INTEGER
889*>          Number of values of M, P, and N.
890*>
891*> line 3:  MVAL, INTEGER array, dimension(NN)
892*>          Values of M (row dimension).
893*>
894*> line 4:  PVAL, INTEGER array, dimension(NN)
895*>          Values of P (row dimension).
896*>
897*> line 5:  NVAL, INTEGER array, dimension(NN)
898*>          Values of N (column dimension).
899*>
900*> line 6:  THRESH, REAL
901*>          Threshold value for the test ratios.  Information will be
902*>          printed about each test for which the test ratio is greater
903*>          than or equal to the threshold.
904*>
905*> line 7:  TSTERR, LOGICAL
906*>          Flag indicating whether or not to test the error exits for
907*>          the LAPACK routines and driver routines.
908*>
909*> line 8:  NEWSD, INTEGER
910*>          A code indicating how to set the random number seed.
911*>          = 0:  Set the seed to a default value before each run
912*>          = 1:  Initialize the seed to a default value only before the
913*>                first run
914*>          = 2:  Like 1, but use the seed values on the next line
915*>
916*> If line 8 was 2:
917*>
918*> line 9:  INTEGER array, dimension (4)
919*>          Four integer values for the random number seed.
920*>
921*> lines 9-EOF:  Lines specifying matrix types, as for NEP.
922*>          The 3-character path name is 'GSV' for the generalized
923*>          SVD routines.
924*>
925*>-----------------------------------------------------------------------
926*>
927*> CSD data file:
928*>
929*> line 1:  'CSD' in columns 1 to 3.
930*>
931*> line 2:  NM, INTEGER
932*>          Number of values of M, P, and N.
933*>
934*> line 3:  MVAL, INTEGER array, dimension(NM)
935*>          Values of M (row and column dimension of orthogonal matrix).
936*>
937*> line 4:  PVAL, INTEGER array, dimension(NM)
938*>          Values of P (row dimension of top-left block).
939*>
940*> line 5:  NVAL, INTEGER array, dimension(NM)
941*>          Values of N (column dimension of top-left block).
942*>
943*> line 6:  THRESH, REAL
944*>          Threshold value for the test ratios.  Information will be
945*>          printed about each test for which the test ratio is greater
946*>          than or equal to the threshold.
947*>
948*> line 7:  TSTERR, LOGICAL
949*>          Flag indicating whether or not to test the error exits for
950*>          the LAPACK routines and driver routines.
951*>
952*> line 8:  NEWSD, INTEGER
953*>          A code indicating how to set the random number seed.
954*>          = 0:  Set the seed to a default value before each run
955*>          = 1:  Initialize the seed to a default value only before the
956*>                first run
957*>          = 2:  Like 1, but use the seed values on the next line
958*>
959*> If line 8 was 2:
960*>
961*> line 9:  INTEGER array, dimension (4)
962*>          Four integer values for the random number seed.
963*>
964*> lines 9-EOF:  Lines specifying matrix types, as for NEP.
965*>          The 3-character path name is 'CSD' for the CSD routine.
966*>
967*>-----------------------------------------------------------------------
968*>
969*> LSE data file:
970*>
971*> line 1:  'LSE' in columns 1 to 3.
972*>
973*> line 2:  NN, INTEGER
974*>          Number of values of M, P, and N.
975*>
976*> line 3:  MVAL, INTEGER array, dimension(NN)
977*>          Values of M.
978*>
979*> line 4:  PVAL, INTEGER array, dimension(NN)
980*>          Values of P.
981*>
982*> line 5:  NVAL, INTEGER array, dimension(NN)
983*>          Values of N, note P <= N <= P+M.
984*>
985*> line 6:  THRESH, REAL
986*>          Threshold value for the test ratios.  Information will be
987*>          printed about each test for which the test ratio is greater
988*>          than or equal to the threshold.
989*>
990*> line 7:  TSTERR, LOGICAL
991*>          Flag indicating whether or not to test the error exits for
992*>          the LAPACK routines and driver routines.
993*>
994*> line 8:  NEWSD, INTEGER
995*>          A code indicating how to set the random number seed.
996*>          = 0:  Set the seed to a default value before each run
997*>          = 1:  Initialize the seed to a default value only before the
998*>                first run
999*>          = 2:  Like 1, but use the seed values on the next line
1000*>
1001*> If line 8 was 2:
1002*>
1003*> line 9:  INTEGER array, dimension (4)
1004*>          Four integer values for the random number seed.
1005*>
1006*> lines 9-EOF:  Lines specifying matrix types, as for NEP.
1007*>          The 3-character path name is 'GSV' for the generalized
1008*>          SVD routines.
1009*>
1010*>-----------------------------------------------------------------------
1011*>
1012*> NMAX is currently set to 132 and must be at least 12 for some of the
1013*> precomputed examples, and LWORK = NMAX*(5*NMAX+20) in the parameter
1014*> statements below.  For SVD, we assume NRHS may be as big as N.  The
1015*> parameter NEED is set to 14 to allow for 14 N-by-N matrices for CGG.
1016*> \endverbatim
1017*
1018*  Arguments:
1019*  ==========
1020*
1021*
1022*  Authors:
1023*  ========
1024*
1025*> \author Univ. of Tennessee
1026*> \author Univ. of California Berkeley
1027*> \author Univ. of Colorado Denver
1028*> \author NAG Ltd.
1029*
1030*> \date November 2015
1031*
1032*> \ingroup complex_eig
1033*
1034*  =====================================================================
1035      PROGRAM CCHKEE
1036*
1037*  -- LAPACK test routine (version 3.6.0) --
1038*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
1039*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
1040*     November 2015
1041*
1042*  =====================================================================
1043*
1044*     .. Parameters ..
1045      INTEGER            NMAX
1046      PARAMETER          ( NMAX = 132 )
1047      INTEGER            NCMAX
1048      PARAMETER          ( NCMAX = 20 )
1049      INTEGER            NEED
1050      PARAMETER          ( NEED = 14 )
1051      INTEGER            LWORK
1052      PARAMETER          ( LWORK = NMAX*( 5*NMAX+20 ) )
1053      INTEGER            LIWORK
1054      PARAMETER          ( LIWORK = NMAX*( NMAX+20 ) )
1055      INTEGER            MAXIN
1056      PARAMETER          ( MAXIN = 20 )
1057      INTEGER            MAXT
1058      PARAMETER          ( MAXT = 30 )
1059      INTEGER            NIN, NOUT
1060      PARAMETER          ( NIN = 5, NOUT = 6 )
1061*     ..
1062*     .. Local Scalars ..
1063      LOGICAL            CBB, CBK, CBL, CES, CEV, CGG, CGK, CGL, CGS,
1064     $                   CGV, CGX, CHB, CSD, CSX, CVX, CXV, FATAL, GLM,
1065     $                   GQR, GSV, LSE, NEP, SEP, SVD, TSTCHK, TSTDIF,
1066     $                   TSTDRV, TSTERR
1067      CHARACTER          C1
1068      CHARACTER*3        C3, PATH
1069      CHARACTER*32       VNAME
1070      CHARACTER*10       INTSTR
1071      CHARACTER*80       LINE
1072      INTEGER            I, I1, IC, INFO, ITMP, K, LENP, MAXTYP, NEWSD,
1073     $                   NK, NN, NPARMS, NRHS, NTYPES,
1074     $                   VERS_MAJOR, VERS_MINOR, VERS_PATCH
1075      REAL               EPS, S1, S2, THRESH, THRSHN
1076*     ..
1077*     .. Local Arrays ..
1078      LOGICAL            DOTYPE( MAXT ), LOGWRK( NMAX )
1079      INTEGER            IOLDSD( 4 ), ISEED( 4 ), IWORK( LIWORK ),
1080     $                   KVAL( MAXIN ), MVAL( MAXIN ), MXBVAL( MAXIN ),
1081     $                   NBCOL( MAXIN ), NBMIN( MAXIN ), NBVAL( MAXIN ),
1082     $                   NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ),
1083     $                   PVAL( MAXIN )
1084      INTEGER            INMIN( MAXIN ), INWIN( MAXIN ), INIBL( MAXIN ),
1085     $                   ISHFTS( MAXIN ), IACC22( MAXIN )
1086      REAL               ALPHA( NMAX ), BETA( NMAX ), DR( NMAX, 12 ),
1087     $                   RESULT( 500 ), RWORK( LWORK ), S( NMAX*NMAX )
1088      COMPLEX            A( NMAX*NMAX, NEED ), B( NMAX*NMAX, 5 ),
1089     $                   C( NCMAX*NCMAX, NCMAX*NCMAX ), DC( NMAX, 6 ),
1090     $                   TAUA( NMAX ), TAUB( NMAX ), WORK( LWORK ),
1091     $                   X( 5*NMAX )
1092*     ..
1093*     .. External Functions ..
1094      LOGICAL            LSAMEN
1095      REAL               SECOND, SLAMCH
1096      EXTERNAL           LSAMEN, SECOND, SLAMCH
1097*     ..
1098*     .. External Subroutines ..
1099      EXTERNAL           ALAREQ, CCHKBB, CCHKBD, CCHKBK, CCHKBL, CCHKEC,
1100     $                   CCHKGG, CCHKGK, CCHKGL, CCHKHB, CCHKHS, CCHKST,
1101     $                   CCKCSD, CCKGLM, CCKGQR, CCKGSV, CCKLSE, CDRGES,
1102     $                   CDRGEV, CDRGSX, CDRGVX, CDRVBD, CDRVES, CDRVEV,
1103     $                   CDRVSG, CDRVST, CDRVSX, CDRVVX, CERRBD,
1104     $                   CERRED, CERRGG, CERRHS, CERRST, ILAVER, XLAENV,
1105     $                   CDRGES3, CDRGEV3
1106*     ..
1107*     .. Intrinsic Functions ..
1108      INTRINSIC          LEN, MIN
1109*     ..
1110*     .. Scalars in Common ..
1111      LOGICAL            LERR, OK
1112      CHARACTER*32       SRNAMT
1113      INTEGER            INFOT, MAXB, NPROC, NSHIFT, NUNIT, SELDIM,
1114     $                   SELOPT
1115*     ..
1116*     .. Arrays in Common ..
1117      LOGICAL            SELVAL( 20 )
1118      INTEGER            IPARMS( 100 )
1119      REAL               SELWI( 20 ), SELWR( 20 )
1120*     ..
1121*     .. Common blocks ..
1122      COMMON             / CENVIR / NPROC, NSHIFT, MAXB
1123      COMMON             / CLAENV / IPARMS
1124      COMMON             / INFOC / INFOT, NUNIT, OK, LERR
1125      COMMON             / SRNAMC / SRNAMT
1126      COMMON             / SSLCT / SELOPT, SELDIM, SELVAL, SELWR, SELWI
1127*     ..
1128*     .. Data statements ..
1129      DATA               INTSTR / '0123456789' /
1130      DATA               IOLDSD / 0, 0, 0, 1 /
1131*     ..
1132*     .. Executable Statements ..
1133*
1134      A = 0.0
1135      B = 0.0
1136      C = 0.0
1137      DC = 0.0
1138      S1 = SECOND( )
1139      FATAL = .FALSE.
1140      NUNIT = NOUT
1141*
1142*     Return to here to read multiple sets of data
1143*
1144   10 CONTINUE
1145*
1146*     Read the first line and set the 3-character test path
1147*
1148      READ( NIN, FMT = '(A80)', END = 380 )LINE
1149      PATH = LINE( 1: 3 )
1150      NEP = LSAMEN( 3, PATH, 'NEP' ) .OR. LSAMEN( 3, PATH, 'CHS' )
1151      SEP = LSAMEN( 3, PATH, 'SEP' ) .OR. LSAMEN( 3, PATH, 'CST' ) .OR.
1152     $      LSAMEN( 3, PATH, 'CSG' )
1153      SVD = LSAMEN( 3, PATH, 'SVD' ) .OR. LSAMEN( 3, PATH, 'CBD' )
1154      CEV = LSAMEN( 3, PATH, 'CEV' )
1155      CES = LSAMEN( 3, PATH, 'CES' )
1156      CVX = LSAMEN( 3, PATH, 'CVX' )
1157      CSX = LSAMEN( 3, PATH, 'CSX' )
1158      CGG = LSAMEN( 3, PATH, 'CGG' )
1159      CGS = LSAMEN( 3, PATH, 'CGS' )
1160      CGX = LSAMEN( 3, PATH, 'CGX' )
1161      CGV = LSAMEN( 3, PATH, 'CGV' )
1162      CXV = LSAMEN( 3, PATH, 'CXV' )
1163      CHB = LSAMEN( 3, PATH, 'CHB' )
1164      CBB = LSAMEN( 3, PATH, 'CBB' )
1165      GLM = LSAMEN( 3, PATH, 'GLM' )
1166      GQR = LSAMEN( 3, PATH, 'GQR' ) .OR. LSAMEN( 3, PATH, 'GRQ' )
1167      GSV = LSAMEN( 3, PATH, 'GSV' )
1168      CSD = LSAMEN( 3, PATH, 'CSD' )
1169      LSE = LSAMEN( 3, PATH, 'LSE' )
1170      CBL = LSAMEN( 3, PATH, 'CBL' )
1171      CBK = LSAMEN( 3, PATH, 'CBK' )
1172      CGL = LSAMEN( 3, PATH, 'CGL' )
1173      CGK = LSAMEN( 3, PATH, 'CGK' )
1174*
1175*     Report values of parameters.
1176*
1177      IF( PATH.EQ.'   ' ) THEN
1178         GO TO 10
1179      ELSE IF( NEP ) THEN
1180         WRITE( NOUT, FMT = 9987 )
1181      ELSE IF( SEP ) THEN
1182         WRITE( NOUT, FMT = 9986 )
1183      ELSE IF( SVD ) THEN
1184         WRITE( NOUT, FMT = 9985 )
1185      ELSE IF( CEV ) THEN
1186         WRITE( NOUT, FMT = 9979 )
1187      ELSE IF( CES ) THEN
1188         WRITE( NOUT, FMT = 9978 )
1189      ELSE IF( CVX ) THEN
1190         WRITE( NOUT, FMT = 9977 )
1191      ELSE IF( CSX ) THEN
1192         WRITE( NOUT, FMT = 9976 )
1193      ELSE IF( CGG ) THEN
1194         WRITE( NOUT, FMT = 9975 )
1195      ELSE IF( CGS ) THEN
1196         WRITE( NOUT, FMT = 9964 )
1197      ELSE IF( CGX ) THEN
1198         WRITE( NOUT, FMT = 9965 )
1199      ELSE IF( CGV ) THEN
1200         WRITE( NOUT, FMT = 9963 )
1201      ELSE IF( CXV ) THEN
1202         WRITE( NOUT, FMT = 9962 )
1203      ELSE IF( CHB ) THEN
1204         WRITE( NOUT, FMT = 9974 )
1205      ELSE IF( CBB ) THEN
1206         WRITE( NOUT, FMT = 9967 )
1207      ELSE IF( GLM ) THEN
1208         WRITE( NOUT, FMT = 9971 )
1209      ELSE IF( GQR ) THEN
1210         WRITE( NOUT, FMT = 9970 )
1211      ELSE IF( GSV ) THEN
1212         WRITE( NOUT, FMT = 9969 )
1213      ELSE IF( CSD ) THEN
1214         WRITE( NOUT, FMT = 9960 )
1215      ELSE IF( LSE ) THEN
1216         WRITE( NOUT, FMT = 9968 )
1217      ELSE IF( CBL ) THEN
1218*
1219*        CGEBAL:  Balancing
1220*
1221         CALL CCHKBL( NIN, NOUT )
1222         GO TO 380
1223      ELSE IF( CBK ) THEN
1224*
1225*        CGEBAK:  Back transformation
1226*
1227         CALL CCHKBK( NIN, NOUT )
1228         GO TO 380
1229      ELSE IF( CGL ) THEN
1230*
1231*        CGGBAL:  Balancing
1232*
1233         CALL CCHKGL( NIN, NOUT )
1234         GO TO 380
1235      ELSE IF( CGK ) THEN
1236*
1237*        CGGBAK:  Back transformation
1238*
1239         CALL CCHKGK( NIN, NOUT )
1240         GO TO 380
1241      ELSE IF( LSAMEN( 3, PATH, 'CEC' ) ) THEN
1242*
1243*        CEC:  Eigencondition estimation
1244*
1245         READ( NIN, FMT = * )THRESH
1246         CALL XLAENV( 1, 1 )
1247         CALL XLAENV( 12, 1 )
1248         TSTERR = .TRUE.
1249         CALL CCHKEC( THRESH, TSTERR, NIN, NOUT )
1250         GO TO 380
1251      ELSE
1252         WRITE( NOUT, FMT = 9992 )PATH
1253         GO TO 380
1254      END IF
1255      CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH )
1256      WRITE( NOUT, FMT = 9972 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH
1257      WRITE( NOUT, FMT = 9984 )
1258*
1259*     Read the number of values of M, P, and N.
1260*
1261      READ( NIN, FMT = * )NN
1262      IF( NN.LT.0 ) THEN
1263         WRITE( NOUT, FMT = 9989 )'   NN ', NN, 1
1264         NN = 0
1265         FATAL = .TRUE.
1266      ELSE IF( NN.GT.MAXIN ) THEN
1267         WRITE( NOUT, FMT = 9988 )'   NN ', NN, MAXIN
1268         NN = 0
1269         FATAL = .TRUE.
1270      END IF
1271*
1272*     Read the values of M
1273*
1274      IF( .NOT.( CGX .OR. CXV ) ) THEN
1275         READ( NIN, FMT = * )( MVAL( I ), I = 1, NN )
1276         IF( SVD ) THEN
1277            VNAME = '    M '
1278         ELSE
1279            VNAME = '    N '
1280         END IF
1281         DO 20 I = 1, NN
1282            IF( MVAL( I ).LT.0 ) THEN
1283               WRITE( NOUT, FMT = 9989 )VNAME, MVAL( I ), 0
1284               FATAL = .TRUE.
1285            ELSE IF( MVAL( I ).GT.NMAX ) THEN
1286               WRITE( NOUT, FMT = 9988 )VNAME, MVAL( I ), NMAX
1287               FATAL = .TRUE.
1288            END IF
1289   20    CONTINUE
1290         WRITE( NOUT, FMT = 9983 )'M:    ', ( MVAL( I ), I = 1, NN )
1291      END IF
1292*
1293*     Read the values of P
1294*
1295      IF( GLM .OR. GQR .OR. GSV .OR. CSD .OR. LSE ) THEN
1296         READ( NIN, FMT = * )( PVAL( I ), I = 1, NN )
1297         DO 30 I = 1, NN
1298            IF( PVAL( I ).LT.0 ) THEN
1299               WRITE( NOUT, FMT = 9989 )' P  ', PVAL( I ), 0
1300               FATAL = .TRUE.
1301            ELSE IF( PVAL( I ).GT.NMAX ) THEN
1302               WRITE( NOUT, FMT = 9988 )' P  ', PVAL( I ), NMAX
1303               FATAL = .TRUE.
1304            END IF
1305   30    CONTINUE
1306         WRITE( NOUT, FMT = 9983 )'P:    ', ( PVAL( I ), I = 1, NN )
1307      END IF
1308*
1309*     Read the values of N
1310*
1311      IF( SVD .OR. CBB .OR. GLM .OR. GQR .OR. GSV .OR. CSD .OR.
1312     $    LSE ) THEN
1313         READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
1314         DO 40 I = 1, NN
1315            IF( NVAL( I ).LT.0 ) THEN
1316               WRITE( NOUT, FMT = 9989 )'    N ', NVAL( I ), 0
1317               FATAL = .TRUE.
1318            ELSE IF( NVAL( I ).GT.NMAX ) THEN
1319               WRITE( NOUT, FMT = 9988 )'    N ', NVAL( I ), NMAX
1320               FATAL = .TRUE.
1321            END IF
1322   40    CONTINUE
1323      ELSE
1324         DO 50 I = 1, NN
1325            NVAL( I ) = MVAL( I )
1326   50    CONTINUE
1327      END IF
1328      IF( .NOT.( CGX .OR. CXV ) ) THEN
1329         WRITE( NOUT, FMT = 9983 )'N:    ', ( NVAL( I ), I = 1, NN )
1330      ELSE
1331         WRITE( NOUT, FMT = 9983 )'N:    ', NN
1332      END IF
1333*
1334*     Read the number of values of K, followed by the values of K
1335*
1336      IF( CHB .OR. CBB ) THEN
1337         READ( NIN, FMT = * )NK
1338         READ( NIN, FMT = * )( KVAL( I ), I = 1, NK )
1339         DO 60 I = 1, NK
1340            IF( KVAL( I ).LT.0 ) THEN
1341               WRITE( NOUT, FMT = 9989 )'    K ', KVAL( I ), 0
1342               FATAL = .TRUE.
1343            ELSE IF( KVAL( I ).GT.NMAX ) THEN
1344               WRITE( NOUT, FMT = 9988 )'    K ', KVAL( I ), NMAX
1345               FATAL = .TRUE.
1346            END IF
1347   60    CONTINUE
1348         WRITE( NOUT, FMT = 9983 )'K:    ', ( KVAL( I ), I = 1, NK )
1349      END IF
1350*
1351      IF( CEV .OR. CES .OR. CVX .OR. CSX ) THEN
1352*
1353*        For the nonsymmetric QR driver routines, only one set of
1354*        parameters is allowed.
1355*
1356         READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ),
1357     $      INMIN( 1 ), INWIN( 1 ), INIBL(1), ISHFTS(1), IACC22(1)
1358         IF( NBVAL( 1 ).LT.1 ) THEN
1359            WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( 1 ), 1
1360            FATAL = .TRUE.
1361         ELSE IF( NBMIN( 1 ).LT.1 ) THEN
1362            WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1
1363            FATAL = .TRUE.
1364         ELSE IF( NXVAL( 1 ).LT.1 ) THEN
1365            WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( 1 ), 1
1366            FATAL = .TRUE.
1367         ELSE IF( INMIN( 1 ).LT.1 ) THEN
1368            WRITE( NOUT, FMT = 9989 )'   INMIN ', INMIN( 1 ), 1
1369            FATAL = .TRUE.
1370         ELSE IF( INWIN( 1 ).LT.1 ) THEN
1371            WRITE( NOUT, FMT = 9989 )'   INWIN ', INWIN( 1 ), 1
1372            FATAL = .TRUE.
1373         ELSE IF( INIBL( 1 ).LT.1 ) THEN
1374            WRITE( NOUT, FMT = 9989 )'   INIBL ', INIBL( 1 ), 1
1375            FATAL = .TRUE.
1376         ELSE IF( ISHFTS( 1 ).LT.1 ) THEN
1377            WRITE( NOUT, FMT = 9989 )'   ISHFTS ', ISHFTS( 1 ), 1
1378            FATAL = .TRUE.
1379         ELSE IF( IACC22( 1 ).LT.0 ) THEN
1380            WRITE( NOUT, FMT = 9989 )'   IACC22 ', IACC22( 1 ), 0
1381            FATAL = .TRUE.
1382         END IF
1383         CALL XLAENV( 1, NBVAL( 1 ) )
1384         CALL XLAENV( 2, NBMIN( 1 ) )
1385         CALL XLAENV( 3, NXVAL( 1 ) )
1386         CALL XLAENV(12, MAX( 11, INMIN( 1 ) ) )
1387         CALL XLAENV(13, INWIN( 1 ) )
1388         CALL XLAENV(14, INIBL( 1 ) )
1389         CALL XLAENV(15, ISHFTS( 1 ) )
1390         CALL XLAENV(16, IACC22( 1 ) )
1391         WRITE( NOUT, FMT = 9983 )'NB:   ', NBVAL( 1 )
1392         WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 )
1393         WRITE( NOUT, FMT = 9983 )'NX:   ', NXVAL( 1 )
1394         WRITE( NOUT, FMT = 9983 )'INMIN:   ', INMIN( 1 )
1395         WRITE( NOUT, FMT = 9983 )'INWIN: ', INWIN( 1 )
1396         WRITE( NOUT, FMT = 9983 )'INIBL: ', INIBL( 1 )
1397         WRITE( NOUT, FMT = 9983 )'ISHFTS: ', ISHFTS( 1 )
1398         WRITE( NOUT, FMT = 9983 )'IACC22: ', IACC22( 1 )
1399*
1400      ELSE IF( CGS .OR. CGX .OR. CGV .OR. CXV ) THEN
1401*
1402*        For the nonsymmetric generalized driver routines, only one set of
1403*        parameters is allowed.
1404*
1405         READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ),
1406     $      NSVAL( 1 ), MXBVAL( 1 )
1407         IF( NBVAL( 1 ).LT.1 ) THEN
1408            WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( 1 ), 1
1409            FATAL = .TRUE.
1410         ELSE IF( NBMIN( 1 ).LT.1 ) THEN
1411            WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1
1412            FATAL = .TRUE.
1413         ELSE IF( NXVAL( 1 ).LT.1 ) THEN
1414            WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( 1 ), 1
1415            FATAL = .TRUE.
1416         ELSE IF( NSVAL( 1 ).LT.2 ) THEN
1417            WRITE( NOUT, FMT = 9989 )'   NS ', NSVAL( 1 ), 2
1418            FATAL = .TRUE.
1419         ELSE IF( MXBVAL( 1 ).LT.1 ) THEN
1420            WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( 1 ), 1
1421            FATAL = .TRUE.
1422         END IF
1423         CALL XLAENV( 1, NBVAL( 1 ) )
1424         CALL XLAENV( 2, NBMIN( 1 ) )
1425         CALL XLAENV( 3, NXVAL( 1 ) )
1426         CALL XLAENV( 4, NSVAL( 1 ) )
1427         CALL XLAENV( 8, MXBVAL( 1 ) )
1428         WRITE( NOUT, FMT = 9983 )'NB:   ', NBVAL( 1 )
1429         WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 )
1430         WRITE( NOUT, FMT = 9983 )'NX:   ', NXVAL( 1 )
1431         WRITE( NOUT, FMT = 9983 )'NS:   ', NSVAL( 1 )
1432         WRITE( NOUT, FMT = 9983 )'MAXB: ', MXBVAL( 1 )
1433      ELSE IF( .NOT.CHB .AND. .NOT.GLM .AND. .NOT.GQR .AND. .NOT.
1434     $         GSV .AND. .NOT.CSD .AND. .NOT.LSE ) THEN
1435*
1436*        For the other paths, the number of parameters can be varied
1437*        from the input file.  Read the number of parameter values.
1438*
1439         READ( NIN, FMT = * )NPARMS
1440         IF( NPARMS.LT.1 ) THEN
1441            WRITE( NOUT, FMT = 9989 )'NPARMS', NPARMS, 1
1442            NPARMS = 0
1443            FATAL = .TRUE.
1444         ELSE IF( NPARMS.GT.MAXIN ) THEN
1445            WRITE( NOUT, FMT = 9988 )'NPARMS', NPARMS, MAXIN
1446            NPARMS = 0
1447            FATAL = .TRUE.
1448         END IF
1449*
1450*        Read the values of NB
1451*
1452         IF( .NOT.CBB ) THEN
1453            READ( NIN, FMT = * )( NBVAL( I ), I = 1, NPARMS )
1454            DO 70 I = 1, NPARMS
1455               IF( NBVAL( I ).LT.0 ) THEN
1456                  WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( I ), 0
1457                  FATAL = .TRUE.
1458               ELSE IF( NBVAL( I ).GT.NMAX ) THEN
1459                  WRITE( NOUT, FMT = 9988 )'   NB ', NBVAL( I ), NMAX
1460                  FATAL = .TRUE.
1461               END IF
1462   70       CONTINUE
1463            WRITE( NOUT, FMT = 9983 )'NB:   ',
1464     $         ( NBVAL( I ), I = 1, NPARMS )
1465         END IF
1466*
1467*        Read the values of NBMIN
1468*
1469         IF( NEP .OR. SEP .OR. SVD .OR. CGG ) THEN
1470            READ( NIN, FMT = * )( NBMIN( I ), I = 1, NPARMS )
1471            DO 80 I = 1, NPARMS
1472               IF( NBMIN( I ).LT.0 ) THEN
1473                  WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( I ), 0
1474                  FATAL = .TRUE.
1475               ELSE IF( NBMIN( I ).GT.NMAX ) THEN
1476                  WRITE( NOUT, FMT = 9988 )'NBMIN ', NBMIN( I ), NMAX
1477                  FATAL = .TRUE.
1478               END IF
1479   80       CONTINUE
1480            WRITE( NOUT, FMT = 9983 )'NBMIN:',
1481     $         ( NBMIN( I ), I = 1, NPARMS )
1482         ELSE
1483            DO 90 I = 1, NPARMS
1484               NBMIN( I ) = 1
1485   90       CONTINUE
1486         END IF
1487*
1488*        Read the values of NX
1489*
1490         IF( NEP .OR. SEP .OR. SVD ) THEN
1491            READ( NIN, FMT = * )( NXVAL( I ), I = 1, NPARMS )
1492            DO 100 I = 1, NPARMS
1493               IF( NXVAL( I ).LT.0 ) THEN
1494                  WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( I ), 0
1495                  FATAL = .TRUE.
1496               ELSE IF( NXVAL( I ).GT.NMAX ) THEN
1497                  WRITE( NOUT, FMT = 9988 )'   NX ', NXVAL( I ), NMAX
1498                  FATAL = .TRUE.
1499               END IF
1500  100       CONTINUE
1501            WRITE( NOUT, FMT = 9983 )'NX:   ',
1502     $         ( NXVAL( I ), I = 1, NPARMS )
1503         ELSE
1504            DO 110 I = 1, NPARMS
1505               NXVAL( I ) = 1
1506  110       CONTINUE
1507         END IF
1508*
1509*        Read the values of NSHIFT (if CGG) or NRHS (if SVD
1510*        or CBB).
1511*
1512         IF( SVD .OR. CBB .OR. CGG ) THEN
1513            READ( NIN, FMT = * )( NSVAL( I ), I = 1, NPARMS )
1514            DO 120 I = 1, NPARMS
1515               IF( NSVAL( I ).LT.0 ) THEN
1516                  WRITE( NOUT, FMT = 9989 )'   NS ', NSVAL( I ), 0
1517                  FATAL = .TRUE.
1518               ELSE IF( NSVAL( I ).GT.NMAX ) THEN
1519                  WRITE( NOUT, FMT = 9988 )'   NS ', NSVAL( I ), NMAX
1520                  FATAL = .TRUE.
1521               END IF
1522  120       CONTINUE
1523            WRITE( NOUT, FMT = 9983 )'NS:   ',
1524     $         ( NSVAL( I ), I = 1, NPARMS )
1525         ELSE
1526            DO 130 I = 1, NPARMS
1527               NSVAL( I ) = 1
1528  130       CONTINUE
1529         END IF
1530*
1531*        Read the values for MAXB.
1532*
1533         IF( CGG ) THEN
1534            READ( NIN, FMT = * )( MXBVAL( I ), I = 1, NPARMS )
1535            DO 140 I = 1, NPARMS
1536               IF( MXBVAL( I ).LT.0 ) THEN
1537                  WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( I ), 0
1538                  FATAL = .TRUE.
1539               ELSE IF( MXBVAL( I ).GT.NMAX ) THEN
1540                  WRITE( NOUT, FMT = 9988 )' MAXB ', MXBVAL( I ), NMAX
1541                  FATAL = .TRUE.
1542               END IF
1543  140       CONTINUE
1544            WRITE( NOUT, FMT = 9983 )'MAXB: ',
1545     $         ( MXBVAL( I ), I = 1, NPARMS )
1546         ELSE
1547            DO 150 I = 1, NPARMS
1548               MXBVAL( I ) = 1
1549  150       CONTINUE
1550         END IF
1551*
1552*        Read the values for INMIN.
1553*
1554         IF( NEP ) THEN
1555            READ( NIN, FMT = * )( INMIN( I ), I = 1, NPARMS )
1556            DO 540 I = 1, NPARMS
1557               IF( INMIN( I ).LT.0 ) THEN
1558                  WRITE( NOUT, FMT = 9989 )' INMIN ', INMIN( I ), 0
1559                  FATAL = .TRUE.
1560               END IF
1561  540       CONTINUE
1562            WRITE( NOUT, FMT = 9983 )'INMIN: ',
1563     $         ( INMIN( I ), I = 1, NPARMS )
1564         ELSE
1565            DO 550 I = 1, NPARMS
1566               INMIN( I ) = 1
1567  550       CONTINUE
1568         END IF
1569*
1570*        Read the values for INWIN.
1571*
1572         IF( NEP ) THEN
1573            READ( NIN, FMT = * )( INWIN( I ), I = 1, NPARMS )
1574            DO 560 I = 1, NPARMS
1575               IF( INWIN( I ).LT.0 ) THEN
1576                  WRITE( NOUT, FMT = 9989 )' INWIN ', INWIN( I ), 0
1577                  FATAL = .TRUE.
1578               END IF
1579  560       CONTINUE
1580            WRITE( NOUT, FMT = 9983 )'INWIN: ',
1581     $         ( INWIN( I ), I = 1, NPARMS )
1582         ELSE
1583            DO 570 I = 1, NPARMS
1584               INWIN( I ) = 1
1585  570       CONTINUE
1586         END IF
1587*
1588*        Read the values for INIBL.
1589*
1590         IF( NEP ) THEN
1591            READ( NIN, FMT = * )( INIBL( I ), I = 1, NPARMS )
1592            DO 580 I = 1, NPARMS
1593               IF( INIBL( I ).LT.0 ) THEN
1594                  WRITE( NOUT, FMT = 9989 )' INIBL ', INIBL( I ), 0
1595                  FATAL = .TRUE.
1596               END IF
1597  580       CONTINUE
1598            WRITE( NOUT, FMT = 9983 )'INIBL: ',
1599     $         ( INIBL( I ), I = 1, NPARMS )
1600         ELSE
1601            DO 590 I = 1, NPARMS
1602               INIBL( I ) = 1
1603  590       CONTINUE
1604         END IF
1605*
1606*        Read the values for ISHFTS.
1607*
1608         IF( NEP ) THEN
1609            READ( NIN, FMT = * )( ISHFTS( I ), I = 1, NPARMS )
1610            DO 600 I = 1, NPARMS
1611               IF( ISHFTS( I ).LT.0 ) THEN
1612                  WRITE( NOUT, FMT = 9989 )' ISHFTS ', ISHFTS( I ), 0
1613                  FATAL = .TRUE.
1614               END IF
1615  600       CONTINUE
1616            WRITE( NOUT, FMT = 9983 )'ISHFTS: ',
1617     $         ( ISHFTS( I ), I = 1, NPARMS )
1618         ELSE
1619            DO 610 I = 1, NPARMS
1620               ISHFTS( I ) = 1
1621  610       CONTINUE
1622         END IF
1623*
1624*        Read the values for IACC22.
1625*
1626         IF( NEP .OR. CGG ) THEN
1627            READ( NIN, FMT = * )( IACC22( I ), I = 1, NPARMS )
1628            DO 620 I = 1, NPARMS
1629               IF( IACC22( I ).LT.0 ) THEN
1630                  WRITE( NOUT, FMT = 9989 )' IACC22 ', IACC22( I ), 0
1631                  FATAL = .TRUE.
1632               END IF
1633  620       CONTINUE
1634            WRITE( NOUT, FMT = 9983 )'IACC22: ',
1635     $         ( IACC22( I ), I = 1, NPARMS )
1636         ELSE
1637            DO 630 I = 1, NPARMS
1638               IACC22( I ) = 1
1639  630       CONTINUE
1640         END IF
1641*
1642*        Read the values for NBCOL.
1643*
1644         IF( CGG ) THEN
1645            READ( NIN, FMT = * )( NBCOL( I ), I = 1, NPARMS )
1646            DO 160 I = 1, NPARMS
1647               IF( NBCOL( I ).LT.0 ) THEN
1648                  WRITE( NOUT, FMT = 9989 )'NBCOL ', NBCOL( I ), 0
1649                  FATAL = .TRUE.
1650               ELSE IF( NBCOL( I ).GT.NMAX ) THEN
1651                  WRITE( NOUT, FMT = 9988 )'NBCOL ', NBCOL( I ), NMAX
1652                  FATAL = .TRUE.
1653               END IF
1654  160       CONTINUE
1655            WRITE( NOUT, FMT = 9983 )'NBCOL:',
1656     $         ( NBCOL( I ), I = 1, NPARMS )
1657         ELSE
1658            DO 170 I = 1, NPARMS
1659               NBCOL( I ) = 1
1660  170       CONTINUE
1661         END IF
1662      END IF
1663*
1664*     Calculate and print the machine dependent constants.
1665*
1666      WRITE( NOUT, FMT = * )
1667      EPS = SLAMCH( 'Underflow threshold' )
1668      WRITE( NOUT, FMT = 9981 )'underflow', EPS
1669      EPS = SLAMCH( 'Overflow threshold' )
1670      WRITE( NOUT, FMT = 9981 )'overflow ', EPS
1671      EPS = SLAMCH( 'Epsilon' )
1672      WRITE( NOUT, FMT = 9981 )'precision', EPS
1673*
1674*     Read the threshold value for the test ratios.
1675*
1676      READ( NIN, FMT = * )THRESH
1677      WRITE( NOUT, FMT = 9982 )THRESH
1678      IF( SEP .OR. SVD .OR. CGG ) THEN
1679*
1680*        Read the flag that indicates whether to test LAPACK routines.
1681*
1682         READ( NIN, FMT = * )TSTCHK
1683*
1684*        Read the flag that indicates whether to test driver routines.
1685*
1686         READ( NIN, FMT = * )TSTDRV
1687      END IF
1688*
1689*     Read the flag that indicates whether to test the error exits.
1690*
1691      READ( NIN, FMT = * )TSTERR
1692*
1693*     Read the code describing how to set the random number seed.
1694*
1695      READ( NIN, FMT = * )NEWSD
1696*
1697*     If NEWSD = 2, read another line with 4 integers for the seed.
1698*
1699      IF( NEWSD.EQ.2 )
1700     $   READ( NIN, FMT = * )( IOLDSD( I ), I = 1, 4 )
1701*
1702      DO 180 I = 1, 4
1703         ISEED( I ) = IOLDSD( I )
1704  180 CONTINUE
1705*
1706      IF( FATAL ) THEN
1707         WRITE( NOUT, FMT = 9999 )
1708         STOP
1709      END IF
1710*
1711*     Read the input lines indicating the test path and its parameters.
1712*     The first three characters indicate the test path, and the number
1713*     of test matrix types must be the first nonblank item in columns
1714*     4-80.
1715*
1716  190 CONTINUE
1717*
1718      IF( .NOT.( CGX .OR. CXV ) ) THEN
1719*
1720  200    CONTINUE
1721         READ( NIN, FMT = '(A80)', END = 380 )LINE
1722         C3 = LINE( 1: 3 )
1723         LENP = LEN( LINE )
1724         I = 3
1725         ITMP = 0
1726         I1 = 0
1727  210    CONTINUE
1728         I = I + 1
1729         IF( I.GT.LENP ) THEN
1730            IF( I1.GT.0 ) THEN
1731               GO TO 240
1732            ELSE
1733               NTYPES = MAXT
1734               GO TO 240
1735            END IF
1736         END IF
1737         IF( LINE( I: I ).NE.' ' .AND. LINE( I: I ).NE.',' ) THEN
1738            I1 = I
1739            C1 = LINE( I1: I1 )
1740*
1741*        Check that a valid integer was read
1742*
1743            DO 220 K = 1, 10
1744               IF( C1.EQ.INTSTR( K: K ) ) THEN
1745                  IC = K - 1
1746                  GO TO 230
1747               END IF
1748  220       CONTINUE
1749            WRITE( NOUT, FMT = 9991 )I, LINE
1750            GO TO 200
1751  230       CONTINUE
1752            ITMP = 10*ITMP + IC
1753            GO TO 210
1754         ELSE IF( I1.GT.0 ) THEN
1755            GO TO 240
1756         ELSE
1757            GO TO 210
1758         END IF
1759  240    CONTINUE
1760         NTYPES = ITMP
1761*
1762*     Skip the tests if NTYPES is <= 0.
1763*
1764         IF( .NOT.( CEV .OR. CES .OR. CVX .OR. CSX .OR. CGV .OR.
1765     $       CGS ) .AND. NTYPES.LE.0 ) THEN
1766            WRITE( NOUT, FMT = 9990 )C3
1767            GO TO 200
1768         END IF
1769*
1770      ELSE
1771         IF( CGX )
1772     $      C3 = 'CGX'
1773         IF( CXV )
1774     $      C3 = 'CXV'
1775      END IF
1776*
1777*     Reset the random number seed.
1778*
1779      IF( NEWSD.EQ.0 ) THEN
1780         DO 250 K = 1, 4
1781            ISEED( K ) = IOLDSD( K )
1782  250    CONTINUE
1783      END IF
1784*
1785      IF( LSAMEN( 3, C3, 'CHS' ) .OR. LSAMEN( 3, C3, 'NEP' ) ) THEN
1786*
1787*        -------------------------------------
1788*        NEP:  Nonsymmetric Eigenvalue Problem
1789*        -------------------------------------
1790*        Vary the parameters
1791*           NB    = block size
1792*           NBMIN = minimum block size
1793*           NX    = crossover point
1794*           NS    = number of shifts
1795*           MAXB  = minimum submatrix size
1796*
1797         MAXTYP = 21
1798         NTYPES = MIN( MAXTYP, NTYPES )
1799         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1800         CALL XLAENV( 1, 1 )
1801         IF( TSTERR )
1802     $      CALL CERRHS( 'CHSEQR', NOUT )
1803         DO 270 I = 1, NPARMS
1804            CALL XLAENV( 1, NBVAL( I ) )
1805            CALL XLAENV( 2, NBMIN( I ) )
1806            CALL XLAENV( 3, NXVAL( I ) )
1807            CALL XLAENV(12, MAX( 11, INMIN( I ) ) )
1808            CALL XLAENV(13, INWIN( I ) )
1809            CALL XLAENV(14, INIBL( I ) )
1810            CALL XLAENV(15, ISHFTS( I ) )
1811            CALL XLAENV(16, IACC22( I ) )
1812*
1813            IF( NEWSD.EQ.0 ) THEN
1814               DO 260 K = 1, 4
1815                  ISEED( K ) = IOLDSD( K )
1816  260          CONTINUE
1817            END IF
1818            WRITE( NOUT, FMT = 9961 )C3, NBVAL( I ), NBMIN( I ),
1819     $         NXVAL( I ), MAX( 11, INMIN(I)),
1820     $         INWIN( I ), INIBL( I ), ISHFTS( I ), IACC22( I )
1821            CALL CCHKHS( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
1822     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
1823     $                   A( 1, 4 ), A( 1, 5 ), NMAX, A( 1, 6 ),
1824     $                   A( 1, 7 ), DC( 1, 1 ), DC( 1, 2 ), A( 1, 8 ),
1825     $                   A( 1, 9 ), A( 1, 10 ), A( 1, 11 ), A( 1, 12 ),
1826     $                   DC( 1, 3 ), WORK, LWORK, RWORK, IWORK, LOGWRK,
1827     $                   RESULT, INFO )
1828            IF( INFO.NE.0 )
1829     $         WRITE( NOUT, FMT = 9980 )'CCHKHS', INFO
1830  270    CONTINUE
1831*
1832      ELSE IF( LSAMEN( 3, C3, 'CST' ) .OR. LSAMEN( 3, C3, 'SEP' ) ) THEN
1833*
1834*        ----------------------------------
1835*        SEP:  Symmetric Eigenvalue Problem
1836*        ----------------------------------
1837*        Vary the parameters
1838*           NB    = block size
1839*           NBMIN = minimum block size
1840*           NX    = crossover point
1841*
1842         MAXTYP = 21
1843         NTYPES = MIN( MAXTYP, NTYPES )
1844         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1845         CALL XLAENV( 1, 1 )
1846         CALL XLAENV( 9, 25 )
1847         IF( TSTERR )
1848     $      CALL CERRST( 'CST', NOUT )
1849         DO 290 I = 1, NPARMS
1850            CALL XLAENV( 1, NBVAL( I ) )
1851            CALL XLAENV( 2, NBMIN( I ) )
1852            CALL XLAENV( 3, NXVAL( I ) )
1853*
1854            IF( NEWSD.EQ.0 ) THEN
1855               DO 280 K = 1, 4
1856                  ISEED( K ) = IOLDSD( K )
1857  280          CONTINUE
1858            END IF
1859            WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ),
1860     $         NXVAL( I )
1861            IF( TSTCHK ) THEN
1862               CALL CCHKST( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
1863     $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ),
1864     $                      DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
1865     $                      DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
1866     $                      DR( 1, 7 ), DR( 1, 8 ), DR( 1, 9 ),
1867     $                      DR( 1, 10 ), DR( 1, 11 ), A( 1, 3 ), NMAX,
1868     $                      A( 1, 4 ), A( 1, 5 ), DC( 1, 1 ), A( 1, 6 ),
1869     $                      WORK, LWORK, RWORK, LWORK, IWORK, LIWORK,
1870     $                      RESULT, INFO )
1871               IF( INFO.NE.0 )
1872     $            WRITE( NOUT, FMT = 9980 )'CCHKST', INFO
1873            END IF
1874            IF( TSTDRV ) THEN
1875               CALL CDRVST( NN, NVAL, 18, DOTYPE, ISEED, THRESH, NOUT,
1876     $                      A( 1, 1 ), NMAX, DR( 1, 3 ), DR( 1, 4 ),
1877     $                      DR( 1, 5 ), DR( 1, 8 ), DR( 1, 9 ),
1878     $                      DR( 1, 10 ), A( 1, 2 ), NMAX, A( 1, 3 ),
1879     $                      DC( 1, 1 ), A( 1, 4 ), WORK, LWORK, RWORK,
1880     $                      LWORK, IWORK, LIWORK, RESULT, INFO )
1881               IF( INFO.NE.0 )
1882     $            WRITE( NOUT, FMT = 9980 )'CDRVST', INFO
1883            END IF
1884  290    CONTINUE
1885*
1886      ELSE IF( LSAMEN( 3, C3, 'CSG' ) ) THEN
1887*
1888*        ----------------------------------------------
1889*        CSG:  Hermitian Generalized Eigenvalue Problem
1890*        ----------------------------------------------
1891*        Vary the parameters
1892*           NB    = block size
1893*           NBMIN = minimum block size
1894*           NX    = crossover point
1895*
1896         MAXTYP = 21
1897         NTYPES = MIN( MAXTYP, NTYPES )
1898         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1899         CALL XLAENV( 9, 25 )
1900         DO 310 I = 1, NPARMS
1901            CALL XLAENV( 1, NBVAL( I ) )
1902            CALL XLAENV( 2, NBMIN( I ) )
1903            CALL XLAENV( 3, NXVAL( I ) )
1904*
1905            IF( NEWSD.EQ.0 ) THEN
1906               DO 300 K = 1, 4
1907                  ISEED( K ) = IOLDSD( K )
1908  300          CONTINUE
1909            END IF
1910            WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ),
1911     $         NXVAL( I )
1912            IF( TSTCHK ) THEN
1913               CALL CDRVSG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
1914     $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
1915     $                      DR( 1, 3 ), A( 1, 3 ), NMAX, A( 1, 4 ),
1916     $                      A( 1, 5 ), A( 1, 6 ), A( 1, 7 ), WORK,
1917     $                      LWORK, RWORK, LWORK, IWORK, LIWORK, RESULT,
1918     $                      INFO )
1919               IF( INFO.NE.0 )
1920     $            WRITE( NOUT, FMT = 9980 )'CDRVSG', INFO
1921            END IF
1922  310    CONTINUE
1923*
1924      ELSE IF( LSAMEN( 3, C3, 'CBD' ) .OR. LSAMEN( 3, C3, 'SVD' ) ) THEN
1925*
1926*        ----------------------------------
1927*        SVD:  Singular Value Decomposition
1928*        ----------------------------------
1929*        Vary the parameters
1930*           NB    = block size
1931*           NBMIN = minimum block size
1932*           NX    = crossover point
1933*           NRHS  = number of right hand sides
1934*
1935         MAXTYP = 16
1936         NTYPES = MIN( MAXTYP, NTYPES )
1937         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1938         CALL XLAENV( 9, 25 )
1939*
1940*        Test the error exits
1941*
1942         CALL XLAENV( 1, 1 )
1943         IF( TSTERR .AND. TSTCHK )
1944     $      CALL CERRBD( 'CBD', NOUT )
1945         IF( TSTERR .AND. TSTDRV )
1946     $      CALL CERRED( 'CBD', NOUT )
1947*
1948         DO 330 I = 1, NPARMS
1949            NRHS = NSVAL( I )
1950            CALL XLAENV( 1, NBVAL( I ) )
1951            CALL XLAENV( 2, NBMIN( I ) )
1952            CALL XLAENV( 3, NXVAL( I ) )
1953            IF( NEWSD.EQ.0 ) THEN
1954               DO 320 K = 1, 4
1955                  ISEED( K ) = IOLDSD( K )
1956  320          CONTINUE
1957            END IF
1958            WRITE( NOUT, FMT = 9995 )C3, NBVAL( I ), NBMIN( I ),
1959     $         NXVAL( I ), NRHS
1960            IF( TSTCHK ) THEN
1961               CALL CCHKBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, NRHS, ISEED,
1962     $                      THRESH, A( 1, 1 ), NMAX, DR( 1, 1 ),
1963     $                      DR( 1, 2 ), DR( 1, 3 ), DR( 1, 4 ),
1964     $                      A( 1, 2 ), NMAX, A( 1, 3 ), A( 1, 4 ),
1965     $                      A( 1, 5 ), NMAX, A( 1, 6 ), NMAX, A( 1, 7 ),
1966     $                      A( 1, 8 ), WORK, LWORK, RWORK, NOUT, INFO )
1967               IF( INFO.NE.0 )
1968     $            WRITE( NOUT, FMT = 9980 )'CCHKBD', INFO
1969            END IF
1970            IF( TSTDRV )
1971     $         CALL CDRVBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, ISEED,
1972     $                      THRESH, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
1973     $                      A( 1, 3 ), NMAX, A( 1, 4 ), A( 1, 5 ),
1974     $                      A( 1, 6 ), DR( 1, 1 ), DR( 1, 2 ),
1975     $                      DR( 1, 3 ), WORK, LWORK, RWORK, IWORK, NOUT,
1976     $                      INFO )
1977  330    CONTINUE
1978*
1979      ELSE IF( LSAMEN( 3, C3, 'CEV' ) ) THEN
1980*
1981*        --------------------------------------------
1982*        CEV:  Nonsymmetric Eigenvalue Problem Driver
1983*              CGEEV (eigenvalues and eigenvectors)
1984*        --------------------------------------------
1985*
1986         MAXTYP = 21
1987         NTYPES = MIN( MAXTYP, NTYPES )
1988         IF( NTYPES.LE.0 ) THEN
1989            WRITE( NOUT, FMT = 9990 )C3
1990         ELSE
1991            IF( TSTERR )
1992     $         CALL CERRED( C3, NOUT )
1993            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1994            CALL CDRVEV( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT,
1995     $                   A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ),
1996     $                   DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX,
1997     $                   A( 1, 5 ), NMAX, RESULT, WORK, LWORK, RWORK,
1998     $                   IWORK, INFO )
1999            IF( INFO.NE.0 )
2000     $         WRITE( NOUT, FMT = 9980 )'CGEEV', INFO
2001         END IF
2002         WRITE( NOUT, FMT = 9973 )
2003         GO TO 10
2004*
2005      ELSE IF( LSAMEN( 3, C3, 'CES' ) ) THEN
2006*
2007*        --------------------------------------------
2008*        CES:  Nonsymmetric Eigenvalue Problem Driver
2009*              CGEES (Schur form)
2010*        --------------------------------------------
2011*
2012         MAXTYP = 21
2013         NTYPES = MIN( MAXTYP, NTYPES )
2014         IF( NTYPES.LE.0 ) THEN
2015            WRITE( NOUT, FMT = 9990 )C3
2016         ELSE
2017            IF( TSTERR )
2018     $         CALL CERRED( C3, NOUT )
2019            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2020            CALL CDRVES( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT,
2021     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2022     $                   DC( 1, 1 ), DC( 1, 2 ), A( 1, 4 ), NMAX,
2023     $                   RESULT, WORK, LWORK, RWORK, IWORK, LOGWRK,
2024     $                   INFO )
2025            IF( INFO.NE.0 )
2026     $         WRITE( NOUT, FMT = 9980 )'CGEES', INFO
2027         END IF
2028         WRITE( NOUT, FMT = 9973 )
2029         GO TO 10
2030*
2031      ELSE IF( LSAMEN( 3, C3, 'CVX' ) ) THEN
2032*
2033*        --------------------------------------------------------------
2034*        CVX:  Nonsymmetric Eigenvalue Problem Expert Driver
2035*              CGEEVX (eigenvalues, eigenvectors and condition numbers)
2036*        --------------------------------------------------------------
2037*
2038         MAXTYP = 21
2039         NTYPES = MIN( MAXTYP, NTYPES )
2040         IF( NTYPES.LT.0 ) THEN
2041            WRITE( NOUT, FMT = 9990 )C3
2042         ELSE
2043            IF( TSTERR )
2044     $         CALL CERRED( C3, NOUT )
2045            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2046            CALL CDRVVX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN,
2047     $                   NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ),
2048     $                   DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX,
2049     $                   A( 1, 5 ), NMAX, DR( 1, 1 ), DR( 1, 2 ),
2050     $                   DR( 1, 3 ), DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
2051     $                   DR( 1, 7 ), DR( 1, 8 ), RESULT, WORK, LWORK,
2052     $                   RWORK, INFO )
2053            IF( INFO.NE.0 )
2054     $         WRITE( NOUT, FMT = 9980 )'CGEEVX', INFO
2055         END IF
2056         WRITE( NOUT, FMT = 9973 )
2057         GO TO 10
2058*
2059      ELSE IF( LSAMEN( 3, C3, 'CSX' ) ) THEN
2060*
2061*        ---------------------------------------------------
2062*        CSX:  Nonsymmetric Eigenvalue Problem Expert Driver
2063*              CGEESX (Schur form and condition numbers)
2064*        ---------------------------------------------------
2065*
2066         MAXTYP = 21
2067         NTYPES = MIN( MAXTYP, NTYPES )
2068         IF( NTYPES.LT.0 ) THEN
2069            WRITE( NOUT, FMT = 9990 )C3
2070         ELSE
2071            IF( TSTERR )
2072     $         CALL CERRED( C3, NOUT )
2073            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2074            CALL CDRVSX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN,
2075     $                   NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2076     $                   DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), A( 1, 4 ),
2077     $                   NMAX, A( 1, 5 ), RESULT, WORK, LWORK, RWORK,
2078     $                   LOGWRK, INFO )
2079            IF( INFO.NE.0 )
2080     $         WRITE( NOUT, FMT = 9980 )'CGEESX', INFO
2081         END IF
2082         WRITE( NOUT, FMT = 9973 )
2083         GO TO 10
2084*
2085      ELSE IF( LSAMEN( 3, C3, 'CGG' ) ) THEN
2086*
2087*        -------------------------------------------------
2088*        CGG:  Generalized Nonsymmetric Eigenvalue Problem
2089*        -------------------------------------------------
2090*        Vary the parameters
2091*           NB    = block size
2092*           NBMIN = minimum block size
2093*           NS    = number of shifts
2094*           MAXB  = minimum submatrix size
2095*           IACC22: structured matrix multiply
2096*           NBCOL = minimum column dimension for blocks
2097*
2098         MAXTYP = 26
2099         NTYPES = MIN( MAXTYP, NTYPES )
2100         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2101         IF( TSTCHK .AND. TSTERR )
2102     $      CALL CERRGG( C3, NOUT )
2103         DO 350 I = 1, NPARMS
2104            CALL XLAENV( 1, NBVAL( I ) )
2105            CALL XLAENV( 2, NBMIN( I ) )
2106            CALL XLAENV( 4, NSVAL( I ) )
2107            CALL XLAENV( 8, MXBVAL( I ) )
2108            CALL XLAENV( 16, IACC22( I ) )
2109            CALL XLAENV( 5, NBCOL( I ) )
2110*
2111            IF( NEWSD.EQ.0 ) THEN
2112               DO 340 K = 1, 4
2113                  ISEED( K ) = IOLDSD( K )
2114  340          CONTINUE
2115            END IF
2116            WRITE( NOUT, FMT = 9996 )C3, NBVAL( I ), NBMIN( I ),
2117     $         NSVAL( I ), MXBVAL( I ), IACC22( I ), NBCOL( I )
2118            TSTDIF = .FALSE.
2119            THRSHN = 10.
2120            IF( TSTCHK ) THEN
2121               CALL CCHKGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
2122     $                      TSTDIF, THRSHN, NOUT, A( 1, 1 ), NMAX,
2123     $                      A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
2124     $                      A( 1, 6 ), A( 1, 7 ), A( 1, 8 ), A( 1, 9 ),
2125     $                      NMAX, A( 1, 10 ), A( 1, 11 ), A( 1, 12 ),
2126     $                      DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ),
2127     $                      DC( 1, 4 ), A( 1, 13 ), A( 1, 14 ), WORK,
2128     $                      LWORK, RWORK, LOGWRK, RESULT, INFO )
2129               IF( INFO.NE.0 )
2130     $            WRITE( NOUT, FMT = 9980 )'CCHKGG', INFO
2131            END IF
2132  350    CONTINUE
2133*
2134      ELSE IF( LSAMEN( 3, C3, 'CGS' ) ) THEN
2135*
2136*        -------------------------------------------------
2137*        CGS:  Generalized Nonsymmetric Eigenvalue Problem
2138*              CGGES (Schur form)
2139*        -------------------------------------------------
2140*
2141         MAXTYP = 26
2142         NTYPES = MIN( MAXTYP, NTYPES )
2143         IF( NTYPES.LE.0 ) THEN
2144            WRITE( NOUT, FMT = 9990 )C3
2145         ELSE
2146            IF( TSTERR )
2147     $         CALL CERRGG( C3, NOUT )
2148            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2149            CALL CDRGES( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2150     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2151     $                   A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2152     $                   DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK,
2153     $                   RESULT, LOGWRK, INFO )
2154*
2155            IF( INFO.NE.0 )
2156     $         WRITE( NOUT, FMT = 9980 )'CDRGES', INFO
2157*
2158* Blocked version
2159*
2160            CALL CDRGES3( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2161     $                    A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2162     $                    A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2163     $                    DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK,
2164     $                    RESULT, LOGWRK, INFO )
2165*
2166            IF( INFO.NE.0 )
2167     $         WRITE( NOUT, FMT = 9980 )'CDRGES3', INFO
2168         END IF
2169         WRITE( NOUT, FMT = 9973 )
2170
2171         GO TO 10
2172*
2173      ELSE IF( CGX ) THEN
2174*
2175*        -------------------------------------------------
2176*        CGX  Generalized Nonsymmetric Eigenvalue Problem
2177*              CGGESX (Schur form and condition numbers)
2178*        -------------------------------------------------
2179*
2180         MAXTYP = 5
2181         NTYPES = MAXTYP
2182         IF( NN.LT.0 ) THEN
2183            WRITE( NOUT, FMT = 9990 )C3
2184         ELSE
2185            IF( TSTERR )
2186     $         CALL CERRGG( C3, NOUT )
2187            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2188            CALL XLAENV( 5, 2 )
2189            CALL CDRGSX( NN, NCMAX, THRESH, NIN, NOUT, A( 1, 1 ), NMAX,
2190     $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
2191     $                   A( 1, 6 ), DC( 1, 1 ), DC( 1, 2 ), C,
2192     $                   NCMAX*NCMAX, S, WORK, LWORK, RWORK, IWORK,
2193     $                   LIWORK, LOGWRK, INFO )
2194            IF( INFO.NE.0 )
2195     $         WRITE( NOUT, FMT = 9980 )'CDRGSX', INFO
2196         END IF
2197         WRITE( NOUT, FMT = 9973 )
2198         GO TO 10
2199*
2200      ELSE IF( LSAMEN( 3, C3, 'CGV' ) ) THEN
2201*
2202*        -------------------------------------------------
2203*        CGV:  Generalized Nonsymmetric Eigenvalue Problem
2204*              CGGEV (Eigenvalue/vector form)
2205*        -------------------------------------------------
2206*
2207         MAXTYP = 26
2208         NTYPES = MIN( MAXTYP, NTYPES )
2209         IF( NTYPES.LE.0 ) THEN
2210            WRITE( NOUT, FMT = 9990 )C3
2211         ELSE
2212            IF( TSTERR )
2213     $         CALL CERRGG( C3, NOUT )
2214            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2215            CALL CDRGEV( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2216     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2217     $                   A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2218     $                   A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ),
2219     $                   DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK,
2220     $                   RESULT, INFO )
2221            IF( INFO.NE.0 )
2222     $         WRITE( NOUT, FMT = 9980 )'CDRGEV', INFO
2223*
2224* Blocked version
2225*
2226            CALL CDRGEV3( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2227     $                    A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2228     $                    A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2229     $                    A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ),
2230     $                    DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK,
2231     $                    RESULT, INFO )
2232            IF( INFO.NE.0 )
2233     $           WRITE( NOUT, FMT = 9980 )'CDRGEV3', INFO
2234         END IF
2235         WRITE( NOUT, FMT = 9973 )
2236         GO TO 10
2237*
2238      ELSE IF( CXV ) THEN
2239*
2240*        -------------------------------------------------
2241*        CXV:  Generalized Nonsymmetric Eigenvalue Problem
2242*              CGGEVX (eigenvalue/vector with condition numbers)
2243*        -------------------------------------------------
2244*
2245         MAXTYP = 2
2246         NTYPES = MAXTYP
2247         IF( NN.LT.0 ) THEN
2248            WRITE( NOUT, FMT = 9990 )C3
2249         ELSE
2250            IF( TSTERR )
2251     $         CALL CERRGG( C3, NOUT )
2252            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2253            CALL CDRGVX( NN, THRESH, NIN, NOUT, A( 1, 1 ), NMAX,
2254     $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), DC( 1, 1 ),
2255     $                   DC( 1, 2 ), A( 1, 5 ), A( 1, 6 ), IWORK( 1 ),
2256     $                   IWORK( 2 ), DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
2257     $                   DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), WORK,
2258     $                   LWORK, RWORK, IWORK( 3 ), LIWORK-2, RESULT,
2259     $                   LOGWRK, INFO )
2260*
2261            IF( INFO.NE.0 )
2262     $         WRITE( NOUT, FMT = 9980 )'CDRGVX', INFO
2263         END IF
2264         WRITE( NOUT, FMT = 9973 )
2265         GO TO 10
2266*
2267      ELSE IF( LSAMEN( 3, C3, 'CHB' ) ) THEN
2268*
2269*        ------------------------------
2270*        CHB:  Hermitian Band Reduction
2271*        ------------------------------
2272*
2273         MAXTYP = 15
2274         NTYPES = MIN( MAXTYP, NTYPES )
2275         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2276         IF( TSTERR )
2277     $      CALL CERRST( 'CHB', NOUT )
2278         CALL CCHKHB( NN, NVAL, NK, KVAL, MAXTYP, DOTYPE, ISEED, THRESH,
2279     $                NOUT, A( 1, 1 ), NMAX, DR( 1, 1 ), DR( 1, 2 ),
2280     $                A( 1, 2 ), NMAX, WORK, LWORK, RWORK, RESULT,
2281     $                INFO )
2282         IF( INFO.NE.0 )
2283     $      WRITE( NOUT, FMT = 9980 )'CCHKHB', INFO
2284*
2285      ELSE IF( LSAMEN( 3, C3, 'CBB' ) ) THEN
2286*
2287*        ------------------------------
2288*        CBB:  General Band Reduction
2289*        ------------------------------
2290*
2291         MAXTYP = 15
2292         NTYPES = MIN( MAXTYP, NTYPES )
2293         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2294         DO 370 I = 1, NPARMS
2295            NRHS = NSVAL( I )
2296*
2297            IF( NEWSD.EQ.0 ) THEN
2298               DO 360 K = 1, 4
2299                  ISEED( K ) = IOLDSD( K )
2300  360          CONTINUE
2301            END IF
2302            WRITE( NOUT, FMT = 9966 )C3, NRHS
2303            CALL CCHKBB( NN, MVAL, NVAL, NK, KVAL, MAXTYP, DOTYPE, NRHS,
2304     $                   ISEED, THRESH, NOUT, A( 1, 1 ), NMAX,
2305     $                   A( 1, 2 ), 2*NMAX, DR( 1, 1 ), DR( 1, 2 ),
2306     $                   A( 1, 4 ), NMAX, A( 1, 5 ), NMAX, A( 1, 6 ),
2307     $                   NMAX, A( 1, 7 ), WORK, LWORK, RWORK, RESULT,
2308     $                   INFO )
2309            IF( INFO.NE.0 )
2310     $         WRITE( NOUT, FMT = 9980 )'CCHKBB', INFO
2311  370    CONTINUE
2312*
2313      ELSE IF( LSAMEN( 3, C3, 'GLM' ) ) THEN
2314*
2315*        -----------------------------------------
2316*        GLM:  Generalized Linear Regression Model
2317*        -----------------------------------------
2318*
2319         CALL XLAENV( 1, 1 )
2320         IF( TSTERR )
2321     $      CALL CERRGG( 'GLM', NOUT )
2322         CALL CCKGLM( NN, NVAL, MVAL, PVAL, NTYPES, ISEED, THRESH, NMAX,
2323     $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X,
2324     $                WORK, DR( 1, 1 ), NIN, NOUT, INFO )
2325         IF( INFO.NE.0 )
2326     $      WRITE( NOUT, FMT = 9980 )'CCKGLM', INFO
2327*
2328      ELSE IF( LSAMEN( 3, C3, 'GQR' ) ) THEN
2329*
2330*        ------------------------------------------
2331*        GQR:  Generalized QR and RQ factorizations
2332*        ------------------------------------------
2333*
2334         CALL XLAENV( 1, 1 )
2335         IF( TSTERR )
2336     $      CALL CERRGG( 'GQR', NOUT )
2337         CALL CCKGQR( NN, MVAL, NN, PVAL, NN, NVAL, NTYPES, ISEED,
2338     $                THRESH, NMAX, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
2339     $                A( 1, 4 ), TAUA, B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
2340     $                B( 1, 4 ), B( 1, 5 ), TAUB, WORK, DR( 1, 1 ), NIN,
2341     $                NOUT, INFO )
2342         IF( INFO.NE.0 )
2343     $      WRITE( NOUT, FMT = 9980 )'CCKGQR', INFO
2344*
2345      ELSE IF( LSAMEN( 3, C3, 'GSV' ) ) THEN
2346*
2347*        ----------------------------------------------
2348*        GSV:  Generalized Singular Value Decomposition
2349*        ----------------------------------------------
2350*
2351         IF( TSTERR )
2352     $      CALL CERRGG( 'GSV', NOUT )
2353         CALL CCKGSV( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
2354     $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
2355     $                A( 1, 3 ), B( 1, 3 ), A( 1, 4 ), ALPHA, BETA,
2356     $                B( 1, 4 ), IWORK, WORK, DR( 1, 1 ), NIN, NOUT,
2357     $                INFO )
2358         IF( INFO.NE.0 )
2359     $      WRITE( NOUT, FMT = 9980 )'CCKGSV', INFO
2360*
2361      ELSE IF( LSAMEN( 3, C3, 'CSD' ) ) THEN
2362*
2363*        ----------------------------------------------
2364*        CSD:  CS Decomposition
2365*        ----------------------------------------------
2366*
2367         CALL XLAENV(1,1)
2368         IF( TSTERR )
2369     $      CALL CERRGG( 'CSD', NOUT )
2370         CALL CCKCSD( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
2371     $                A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), A( 1, 4 ),
2372     $                A( 1, 5 ), A( 1, 6 ), RWORK, IWORK, WORK,
2373     $                DR( 1, 1 ), NIN, NOUT, INFO )
2374         IF( INFO.NE.0 )
2375     $      WRITE( NOUT, FMT = 9980 )'CCKCSD', INFO
2376*
2377      ELSE IF( LSAMEN( 3, C3, 'LSE' ) ) THEN
2378*
2379*        --------------------------------------
2380*        LSE:  Constrained Linear Least Squares
2381*        --------------------------------------
2382*
2383         CALL XLAENV( 1, 1 )
2384         IF( TSTERR )
2385     $      CALL CERRGG( 'LSE', NOUT )
2386         CALL CCKLSE( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
2387     $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X,
2388     $                WORK, DR( 1, 1 ), NIN, NOUT, INFO )
2389         IF( INFO.NE.0 )
2390     $      WRITE( NOUT, FMT = 9980 )'CCKLSE', INFO
2391      ELSE
2392         WRITE( NOUT, FMT = * )
2393         WRITE( NOUT, FMT = * )
2394         WRITE( NOUT, FMT = 9992 )C3
2395      END IF
2396      IF( .NOT.( CGX .OR. CXV ) )
2397     $   GO TO 190
2398  380 CONTINUE
2399      WRITE( NOUT, FMT = 9994 )
2400      S2 = SECOND( )
2401      WRITE( NOUT, FMT = 9993 )S2 - S1
2402*
2403 9999 FORMAT( / ' Execution not attempted due to input errors' )
2404 9997 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4 )
2405 9996 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NS =', I4,
2406     $      ', MAXB =', I4, ', IACC22 =', I4, ', NBCOL =', I4 )
2407 9995 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
2408     $      ', NRHS =', I4 )
2409 9994 FORMAT( / / ' End of tests' )
2410 9993 FORMAT( ' Total time used = ', F12.2, ' seconds', / )
2411 9992 FORMAT( 1X, A3, ':  Unrecognized path name' )
2412 9991 FORMAT( / / ' *** Invalid integer value in column ', I2,
2413     $      ' of input', ' line:', / A79 )
2414 9990 FORMAT( / / 1X, A3, ' routines were not tested' )
2415 9989 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be >=',
2416     $      I6 )
2417 9988 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be <=',
2418     $      I6 )
2419 9987 FORMAT( ' Tests of the Nonsymmetric Eigenvalue Problem routines' )
2420 9986 FORMAT( ' Tests of the Hermitian Eigenvalue Problem routines' )
2421 9985 FORMAT( ' Tests of the Singular Value Decomposition routines' )
2422 9984 FORMAT( / ' The following parameter values will be used:' )
2423 9983 FORMAT( 4X, A, 10I6, / 10X, 10I6 )
2424 9982 FORMAT( / ' Routines pass computational tests if test ratio is ',
2425     $      'less than', F8.2, / )
2426 9981 FORMAT( ' Relative machine ', A, ' is taken to be', E16.6 )
2427 9980 FORMAT( ' *** Error code from ', A, ' = ', I4 )
2428 9979 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver',
2429     $      / '    CGEEV (eigenvalues and eigevectors)' )
2430 9978 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver',
2431     $      / '    CGEES (Schur form)' )
2432 9977 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert',
2433     $      ' Driver', / '    CGEEVX (eigenvalues, eigenvectors and',
2434     $      ' condition numbers)' )
2435 9976 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert',
2436     $      ' Driver', / '    CGEESX (Schur form and condition',
2437     $      ' numbers)' )
2438 9975 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2439     $      'Problem routines' )
2440 9974 FORMAT( ' Tests of CHBTRD', / ' (reduction of a Hermitian band ',
2441     $      'matrix to real tridiagonal form)' )
2442 9973 FORMAT( / 1X, 71( '-' ) )
2443 9972 FORMAT( / ' LAPACK VERSION ', I1, '.', I1, '.', I1 )
2444 9971 FORMAT( / ' Tests of the Generalized Linear Regression Model ',
2445     $      'routines' )
2446 9970 FORMAT( / ' Tests of the Generalized QR and RQ routines' )
2447 9969 FORMAT( / ' Tests of the Generalized Singular Value',
2448     $      ' Decomposition routines' )
2449 9968 FORMAT( / ' Tests of the Linear Least Squares routines' )
2450 9967 FORMAT( ' Tests of CGBBRD', / ' (reduction of a general band ',
2451     $      'matrix to real bidiagonal form)' )
2452 9966 FORMAT( / / 1X, A3, ':  NRHS =', I4 )
2453 9965 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2454     $      'Problem Expert Driver CGGESX' )
2455 9964 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2456     $      'Problem Driver CGGES' )
2457 9963 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2458     $      'Problem Driver CGGEV' )
2459 9962 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2460     $      'Problem Expert Driver CGGEVX' )
2461 9961 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
2462     $      ', INMIN=', I4,
2463     $      ', INWIN =', I4, ', INIBL =', I4, ', ISHFTS =', I4,
2464     $      ', IACC22 =', I4)
2465 9960 FORMAT( / ' Tests of the CS Decomposition routines' )
2466*
2467*     End of CCHKEE
2468*
2469      END
2470