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 June 2016
1031*
1032*> \ingroup complex_eig
1033*
1034*  =====================================================================
1035      PROGRAM CCHKEE
1036*
1037#if defined(_OPENMP)
1038      use omp_lib
1039#endif
1040*
1041*  -- LAPACK test routine (version 3.7.0) --
1042*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
1043*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
1044*     June 2016
1045*
1046*  =====================================================================
1047*
1048*     .. Parameters ..
1049      INTEGER            NMAX
1050      PARAMETER          ( NMAX = 132 )
1051      INTEGER            NCMAX
1052      PARAMETER          ( NCMAX = 20 )
1053      INTEGER            NEED
1054      PARAMETER          ( NEED = 14 )
1055      INTEGER            LWORK
1056      PARAMETER          ( LWORK = NMAX*( 5*NMAX+20 ) )
1057      INTEGER            LIWORK
1058      PARAMETER          ( LIWORK = NMAX*( NMAX+20 ) )
1059      INTEGER            MAXIN
1060      PARAMETER          ( MAXIN = 20 )
1061      INTEGER            MAXT
1062      PARAMETER          ( MAXT = 30 )
1063      INTEGER            NIN, NOUT
1064      PARAMETER          ( NIN = 5, NOUT = 6 )
1065*     ..
1066*     .. Local Scalars ..
1067      LOGICAL            CBB, CBK, CBL, CES, CEV, CGG, CGK, CGL, CGS,
1068     $                   CGV, CGX, CHB, CSD, CSX, CVX, CXV, FATAL, GLM,
1069     $                   GQR, GSV, LSE, NEP, SEP, SVD, TSTCHK, TSTDIF,
1070     $                   TSTDRV, TSTERR
1071      CHARACTER          C1
1072      CHARACTER*3        C3, PATH
1073      CHARACTER*32       VNAME
1074      CHARACTER*10       INTSTR
1075      CHARACTER*80       LINE
1076      INTEGER            I, I1, IC, INFO, ITMP, K, LENP, MAXTYP, NEWSD,
1077     $                   NK, NN, NPARMS, NRHS, NTYPES,
1078     $                   VERS_MAJOR, VERS_MINOR, VERS_PATCH
1079      INTEGER*4          N_THREADS, ONE_THREAD
1080      REAL               EPS, S1, S2, THRESH, THRSHN
1081*     ..
1082*     .. Local Arrays ..
1083      LOGICAL            DOTYPE( MAXT ), LOGWRK( NMAX )
1084      INTEGER            IOLDSD( 4 ), ISEED( 4 ), IWORK( LIWORK ),
1085     $                   KVAL( MAXIN ), MVAL( MAXIN ), MXBVAL( MAXIN ),
1086     $                   NBCOL( MAXIN ), NBMIN( MAXIN ), NBVAL( MAXIN ),
1087     $                   NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ),
1088     $                   PVAL( MAXIN )
1089      INTEGER            INMIN( MAXIN ), INWIN( MAXIN ), INIBL( MAXIN ),
1090     $                   ISHFTS( MAXIN ), IACC22( MAXIN )
1091      REAL               ALPHA( NMAX ), BETA( NMAX ), DR( NMAX, 12 ),
1092     $                   RESULT( 500 )
1093      COMPLEX            DC( NMAX, 6 ), TAUA( NMAX ), TAUB( NMAX ),
1094     $                   X( 5*NMAX )
1095*     ..
1096*     .. Allocatable Arrays ..
1097      INTEGER AllocateStatus
1098      REAL, DIMENSION(:), ALLOCATABLE :: RWORK, S
1099      COMPLEX, DIMENSION(:), ALLOCATABLE :: WORK
1100      COMPLEX, DIMENSION(:,:), ALLOCATABLE :: A, B, C
1101*     ..
1102*     .. External Functions ..
1103      LOGICAL            LSAMEN
1104      REAL               SECOND, SLAMCH
1105      EXTERNAL           LSAMEN, SECOND, SLAMCH
1106*     ..
1107*     .. External Subroutines ..
1108      EXTERNAL           ALAREQ, CCHKBB, CCHKBD, CCHKBK, CCHKBL, CCHKEC,
1109     $                   CCHKGG, CCHKGK, CCHKGL, CCHKHB, CCHKHS, CCHKST,
1110     $                   CCKCSD, CCKGLM, CCKGQR, CCKGSV, CCKLSE, CDRGES,
1111     $                   CDRGEV, CDRGSX, CDRGVX, CDRVBD, CDRVES, CDRVEV,
1112     $                   CDRVSG, CDRVST, CDRVSX, CDRVVX, CERRBD,
1113     $                   CERRED, CERRGG, CERRHS, CERRST, ILAVER, XLAENV,
1114     $                   CDRGES3, CDRGEV3,
1115     $                   CCHKST2STG, CDRVST2STG, CCHKHB2STG
1116*     ..
1117*     .. Intrinsic Functions ..
1118      INTRINSIC          LEN, MIN
1119*     ..
1120*     .. Scalars in Common ..
1121      LOGICAL            LERR, OK
1122      CHARACTER*32       SRNAMT
1123      INTEGER            INFOT, MAXB, NPROC, NSHIFT, NUNIT, SELDIM,
1124     $                   SELOPT
1125*     ..
1126*     .. Arrays in Common ..
1127      LOGICAL            SELVAL( 20 )
1128      INTEGER            IPARMS( 100 )
1129      REAL               SELWI( 20 ), SELWR( 20 )
1130*     ..
1131*     .. Common blocks ..
1132      COMMON             / CENVIR / NPROC, NSHIFT, MAXB
1133      COMMON             / CLAENV / IPARMS
1134      COMMON             / INFOC / INFOT, NUNIT, OK, LERR
1135      COMMON             / SRNAMC / SRNAMT
1136      COMMON             / SSLCT / SELOPT, SELDIM, SELVAL, SELWR, SELWI
1137*     ..
1138*     .. Data statements ..
1139      DATA               INTSTR / '0123456789' /
1140      DATA               IOLDSD / 0, 0, 0, 1 /
1141*     ..
1142*     .. Allocate memory dynamically ..
1143*
1144      ALLOCATE ( S(NMAX*NMAX), STAT = AllocateStatus )
1145      IF (AllocateStatus /= 0) STOP "*** Not enough memory ***"
1146      ALLOCATE ( A(NMAX*NMAX,NEED), STAT = AllocateStatus )
1147      IF (AllocateStatus /= 0) STOP "*** Not enough memory ***"
1148      ALLOCATE ( B(NMAX*NMAX,5), STAT = AllocateStatus )
1149      IF (AllocateStatus /= 0) STOP "*** Not enough memory ***"
1150      ALLOCATE ( C(NCMAX*NCMAX,NCMAX*NCMAX), STAT = AllocateStatus )
1151      IF (AllocateStatus /= 0) STOP "*** Not enough memory ***"
1152      ALLOCATE ( RWORK(LWORK), STAT = AllocateStatus )
1153      IF (AllocateStatus /= 0) STOP "*** Not enough memory ***"
1154      ALLOCATE ( WORK(LWORK), STAT = AllocateStatus )
1155      IF (AllocateStatus /= 0) STOP "*** Not enough memory ***"
1156*     ..
1157*     .. Executable Statements ..
1158*
1159      A = 0.0
1160      B = 0.0
1161      C = 0.0
1162      DC = 0.0
1163      S1 = SECOND( )
1164      FATAL = .FALSE.
1165      NUNIT = NOUT
1166*
1167*     Return to here to read multiple sets of data
1168*
1169   10 CONTINUE
1170*
1171*     Read the first line and set the 3-character test path
1172*
1173      READ( NIN, FMT = '(A80)', END = 380 )LINE
1174      PATH = LINE( 1: 3 )
1175      NEP = LSAMEN( 3, PATH, 'NEP' ) .OR. LSAMEN( 3, PATH, 'CHS' )
1176      SEP = LSAMEN( 3, PATH, 'SEP' ) .OR. LSAMEN( 3, PATH, 'CST' ) .OR.
1177     $      LSAMEN( 3, PATH, 'CSG' ) .OR. LSAMEN( 3, PATH, 'SE2' )
1178      SVD = LSAMEN( 3, PATH, 'SVD' ) .OR. LSAMEN( 3, PATH, 'CBD' )
1179      CEV = LSAMEN( 3, PATH, 'CEV' )
1180      CES = LSAMEN( 3, PATH, 'CES' )
1181      CVX = LSAMEN( 3, PATH, 'CVX' )
1182      CSX = LSAMEN( 3, PATH, 'CSX' )
1183      CGG = LSAMEN( 3, PATH, 'CGG' )
1184      CGS = LSAMEN( 3, PATH, 'CGS' )
1185      CGX = LSAMEN( 3, PATH, 'CGX' )
1186      CGV = LSAMEN( 3, PATH, 'CGV' )
1187      CXV = LSAMEN( 3, PATH, 'CXV' )
1188      CHB = LSAMEN( 3, PATH, 'CHB' )
1189      CBB = LSAMEN( 3, PATH, 'CBB' )
1190      GLM = LSAMEN( 3, PATH, 'GLM' )
1191      GQR = LSAMEN( 3, PATH, 'GQR' ) .OR. LSAMEN( 3, PATH, 'GRQ' )
1192      GSV = LSAMEN( 3, PATH, 'GSV' )
1193      CSD = LSAMEN( 3, PATH, 'CSD' )
1194      LSE = LSAMEN( 3, PATH, 'LSE' )
1195      CBL = LSAMEN( 3, PATH, 'CBL' )
1196      CBK = LSAMEN( 3, PATH, 'CBK' )
1197      CGL = LSAMEN( 3, PATH, 'CGL' )
1198      CGK = LSAMEN( 3, PATH, 'CGK' )
1199*
1200*     Report values of parameters.
1201*
1202      IF( PATH.EQ.'   ' ) THEN
1203         GO TO 10
1204      ELSE IF( NEP ) THEN
1205         WRITE( NOUT, FMT = 9987 )
1206      ELSE IF( SEP ) THEN
1207         WRITE( NOUT, FMT = 9986 )
1208      ELSE IF( SVD ) THEN
1209         WRITE( NOUT, FMT = 9985 )
1210      ELSE IF( CEV ) THEN
1211         WRITE( NOUT, FMT = 9979 )
1212      ELSE IF( CES ) THEN
1213         WRITE( NOUT, FMT = 9978 )
1214      ELSE IF( CVX ) THEN
1215         WRITE( NOUT, FMT = 9977 )
1216      ELSE IF( CSX ) THEN
1217         WRITE( NOUT, FMT = 9976 )
1218      ELSE IF( CGG ) THEN
1219         WRITE( NOUT, FMT = 9975 )
1220      ELSE IF( CGS ) THEN
1221         WRITE( NOUT, FMT = 9964 )
1222      ELSE IF( CGX ) THEN
1223         WRITE( NOUT, FMT = 9965 )
1224      ELSE IF( CGV ) THEN
1225         WRITE( NOUT, FMT = 9963 )
1226      ELSE IF( CXV ) THEN
1227         WRITE( NOUT, FMT = 9962 )
1228      ELSE IF( CHB ) THEN
1229         WRITE( NOUT, FMT = 9974 )
1230      ELSE IF( CBB ) THEN
1231         WRITE( NOUT, FMT = 9967 )
1232      ELSE IF( GLM ) THEN
1233         WRITE( NOUT, FMT = 9971 )
1234      ELSE IF( GQR ) THEN
1235         WRITE( NOUT, FMT = 9970 )
1236      ELSE IF( GSV ) THEN
1237         WRITE( NOUT, FMT = 9969 )
1238      ELSE IF( CSD ) THEN
1239         WRITE( NOUT, FMT = 9960 )
1240      ELSE IF( LSE ) THEN
1241         WRITE( NOUT, FMT = 9968 )
1242      ELSE IF( CBL ) THEN
1243*
1244*        CGEBAL:  Balancing
1245*
1246         CALL CCHKBL( NIN, NOUT )
1247         GO TO 380
1248      ELSE IF( CBK ) THEN
1249*
1250*        CGEBAK:  Back transformation
1251*
1252         CALL CCHKBK( NIN, NOUT )
1253         GO TO 380
1254      ELSE IF( CGL ) THEN
1255*
1256*        CGGBAL:  Balancing
1257*
1258         CALL CCHKGL( NIN, NOUT )
1259         GO TO 380
1260      ELSE IF( CGK ) THEN
1261*
1262*        CGGBAK:  Back transformation
1263*
1264         CALL CCHKGK( NIN, NOUT )
1265         GO TO 380
1266      ELSE IF( LSAMEN( 3, PATH, 'CEC' ) ) THEN
1267*
1268*        CEC:  Eigencondition estimation
1269*
1270         READ( NIN, FMT = * )THRESH
1271         CALL XLAENV( 1, 1 )
1272         CALL XLAENV( 12, 1 )
1273         TSTERR = .TRUE.
1274         CALL CCHKEC( THRESH, TSTERR, NIN, NOUT )
1275         GO TO 380
1276      ELSE
1277         WRITE( NOUT, FMT = 9992 )PATH
1278         GO TO 380
1279      END IF
1280      CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH )
1281      WRITE( NOUT, FMT = 9972 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH
1282      WRITE( NOUT, FMT = 9984 )
1283*
1284*     Read the number of values of M, P, and N.
1285*
1286      READ( NIN, FMT = * )NN
1287      IF( NN.LT.0 ) THEN
1288         WRITE( NOUT, FMT = 9989 )'   NN ', NN, 1
1289         NN = 0
1290         FATAL = .TRUE.
1291      ELSE IF( NN.GT.MAXIN ) THEN
1292         WRITE( NOUT, FMT = 9988 )'   NN ', NN, MAXIN
1293         NN = 0
1294         FATAL = .TRUE.
1295      END IF
1296*
1297*     Read the values of M
1298*
1299      IF( .NOT.( CGX .OR. CXV ) ) THEN
1300         READ( NIN, FMT = * )( MVAL( I ), I = 1, NN )
1301         IF( SVD ) THEN
1302            VNAME = '    M '
1303         ELSE
1304            VNAME = '    N '
1305         END IF
1306         DO 20 I = 1, NN
1307            IF( MVAL( I ).LT.0 ) THEN
1308               WRITE( NOUT, FMT = 9989 )VNAME, MVAL( I ), 0
1309               FATAL = .TRUE.
1310            ELSE IF( MVAL( I ).GT.NMAX ) THEN
1311               WRITE( NOUT, FMT = 9988 )VNAME, MVAL( I ), NMAX
1312               FATAL = .TRUE.
1313            END IF
1314   20    CONTINUE
1315         WRITE( NOUT, FMT = 9983 )'M:    ', ( MVAL( I ), I = 1, NN )
1316      END IF
1317*
1318*     Read the values of P
1319*
1320      IF( GLM .OR. GQR .OR. GSV .OR. CSD .OR. LSE ) THEN
1321         READ( NIN, FMT = * )( PVAL( I ), I = 1, NN )
1322         DO 30 I = 1, NN
1323            IF( PVAL( I ).LT.0 ) THEN
1324               WRITE( NOUT, FMT = 9989 )' P  ', PVAL( I ), 0
1325               FATAL = .TRUE.
1326            ELSE IF( PVAL( I ).GT.NMAX ) THEN
1327               WRITE( NOUT, FMT = 9988 )' P  ', PVAL( I ), NMAX
1328               FATAL = .TRUE.
1329            END IF
1330   30    CONTINUE
1331         WRITE( NOUT, FMT = 9983 )'P:    ', ( PVAL( I ), I = 1, NN )
1332      END IF
1333*
1334*     Read the values of N
1335*
1336      IF( SVD .OR. CBB .OR. GLM .OR. GQR .OR. GSV .OR. CSD .OR.
1337     $    LSE ) THEN
1338         READ( NIN, FMT = * )( NVAL( I ), I = 1, NN )
1339         DO 40 I = 1, NN
1340            IF( NVAL( I ).LT.0 ) THEN
1341               WRITE( NOUT, FMT = 9989 )'    N ', NVAL( I ), 0
1342               FATAL = .TRUE.
1343            ELSE IF( NVAL( I ).GT.NMAX ) THEN
1344               WRITE( NOUT, FMT = 9988 )'    N ', NVAL( I ), NMAX
1345               FATAL = .TRUE.
1346            END IF
1347   40    CONTINUE
1348      ELSE
1349         DO 50 I = 1, NN
1350            NVAL( I ) = MVAL( I )
1351   50    CONTINUE
1352      END IF
1353      IF( .NOT.( CGX .OR. CXV ) ) THEN
1354         WRITE( NOUT, FMT = 9983 )'N:    ', ( NVAL( I ), I = 1, NN )
1355      ELSE
1356         WRITE( NOUT, FMT = 9983 )'N:    ', NN
1357      END IF
1358*
1359*     Read the number of values of K, followed by the values of K
1360*
1361      IF( CHB .OR. CBB ) THEN
1362         READ( NIN, FMT = * )NK
1363         READ( NIN, FMT = * )( KVAL( I ), I = 1, NK )
1364         DO 60 I = 1, NK
1365            IF( KVAL( I ).LT.0 ) THEN
1366               WRITE( NOUT, FMT = 9989 )'    K ', KVAL( I ), 0
1367               FATAL = .TRUE.
1368            ELSE IF( KVAL( I ).GT.NMAX ) THEN
1369               WRITE( NOUT, FMT = 9988 )'    K ', KVAL( I ), NMAX
1370               FATAL = .TRUE.
1371            END IF
1372   60    CONTINUE
1373         WRITE( NOUT, FMT = 9983 )'K:    ', ( KVAL( I ), I = 1, NK )
1374      END IF
1375*
1376      IF( CEV .OR. CES .OR. CVX .OR. CSX ) THEN
1377*
1378*        For the nonsymmetric QR driver routines, only one set of
1379*        parameters is allowed.
1380*
1381         READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ),
1382     $      INMIN( 1 ), INWIN( 1 ), INIBL(1), ISHFTS(1), IACC22(1)
1383         IF( NBVAL( 1 ).LT.1 ) THEN
1384            WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( 1 ), 1
1385            FATAL = .TRUE.
1386         ELSE IF( NBMIN( 1 ).LT.1 ) THEN
1387            WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1
1388            FATAL = .TRUE.
1389         ELSE IF( NXVAL( 1 ).LT.1 ) THEN
1390            WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( 1 ), 1
1391            FATAL = .TRUE.
1392         ELSE IF( INMIN( 1 ).LT.1 ) THEN
1393            WRITE( NOUT, FMT = 9989 )'   INMIN ', INMIN( 1 ), 1
1394            FATAL = .TRUE.
1395         ELSE IF( INWIN( 1 ).LT.1 ) THEN
1396            WRITE( NOUT, FMT = 9989 )'   INWIN ', INWIN( 1 ), 1
1397            FATAL = .TRUE.
1398         ELSE IF( INIBL( 1 ).LT.1 ) THEN
1399            WRITE( NOUT, FMT = 9989 )'   INIBL ', INIBL( 1 ), 1
1400            FATAL = .TRUE.
1401         ELSE IF( ISHFTS( 1 ).LT.1 ) THEN
1402            WRITE( NOUT, FMT = 9989 )'   ISHFTS ', ISHFTS( 1 ), 1
1403            FATAL = .TRUE.
1404         ELSE IF( IACC22( 1 ).LT.0 ) THEN
1405            WRITE( NOUT, FMT = 9989 )'   IACC22 ', IACC22( 1 ), 0
1406            FATAL = .TRUE.
1407         END IF
1408         CALL XLAENV( 1, NBVAL( 1 ) )
1409         CALL XLAENV( 2, NBMIN( 1 ) )
1410         CALL XLAENV( 3, NXVAL( 1 ) )
1411         CALL XLAENV(12, MAX( 11, INMIN( 1 ) ) )
1412         CALL XLAENV(13, INWIN( 1 ) )
1413         CALL XLAENV(14, INIBL( 1 ) )
1414         CALL XLAENV(15, ISHFTS( 1 ) )
1415         CALL XLAENV(16, IACC22( 1 ) )
1416         WRITE( NOUT, FMT = 9983 )'NB:   ', NBVAL( 1 )
1417         WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 )
1418         WRITE( NOUT, FMT = 9983 )'NX:   ', NXVAL( 1 )
1419         WRITE( NOUT, FMT = 9983 )'INMIN:   ', INMIN( 1 )
1420         WRITE( NOUT, FMT = 9983 )'INWIN: ', INWIN( 1 )
1421         WRITE( NOUT, FMT = 9983 )'INIBL: ', INIBL( 1 )
1422         WRITE( NOUT, FMT = 9983 )'ISHFTS: ', ISHFTS( 1 )
1423         WRITE( NOUT, FMT = 9983 )'IACC22: ', IACC22( 1 )
1424*
1425      ELSE IF( CGS .OR. CGX .OR. CGV .OR. CXV ) THEN
1426*
1427*        For the nonsymmetric generalized driver routines, only one set of
1428*        parameters is allowed.
1429*
1430         READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ),
1431     $      NSVAL( 1 ), MXBVAL( 1 )
1432         IF( NBVAL( 1 ).LT.1 ) THEN
1433            WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( 1 ), 1
1434            FATAL = .TRUE.
1435         ELSE IF( NBMIN( 1 ).LT.1 ) THEN
1436            WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1
1437            FATAL = .TRUE.
1438         ELSE IF( NXVAL( 1 ).LT.1 ) THEN
1439            WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( 1 ), 1
1440            FATAL = .TRUE.
1441         ELSE IF( NSVAL( 1 ).LT.2 ) THEN
1442            WRITE( NOUT, FMT = 9989 )'   NS ', NSVAL( 1 ), 2
1443            FATAL = .TRUE.
1444         ELSE IF( MXBVAL( 1 ).LT.1 ) THEN
1445            WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( 1 ), 1
1446            FATAL = .TRUE.
1447         END IF
1448         CALL XLAENV( 1, NBVAL( 1 ) )
1449         CALL XLAENV( 2, NBMIN( 1 ) )
1450         CALL XLAENV( 3, NXVAL( 1 ) )
1451         CALL XLAENV( 4, NSVAL( 1 ) )
1452         CALL XLAENV( 8, MXBVAL( 1 ) )
1453         WRITE( NOUT, FMT = 9983 )'NB:   ', NBVAL( 1 )
1454         WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 )
1455         WRITE( NOUT, FMT = 9983 )'NX:   ', NXVAL( 1 )
1456         WRITE( NOUT, FMT = 9983 )'NS:   ', NSVAL( 1 )
1457         WRITE( NOUT, FMT = 9983 )'MAXB: ', MXBVAL( 1 )
1458      ELSE IF( .NOT.CHB .AND. .NOT.GLM .AND. .NOT.GQR .AND. .NOT.
1459     $         GSV .AND. .NOT.CSD .AND. .NOT.LSE ) THEN
1460*
1461*        For the other paths, the number of parameters can be varied
1462*        from the input file.  Read the number of parameter values.
1463*
1464         READ( NIN, FMT = * )NPARMS
1465         IF( NPARMS.LT.1 ) THEN
1466            WRITE( NOUT, FMT = 9989 )'NPARMS', NPARMS, 1
1467            NPARMS = 0
1468            FATAL = .TRUE.
1469         ELSE IF( NPARMS.GT.MAXIN ) THEN
1470            WRITE( NOUT, FMT = 9988 )'NPARMS', NPARMS, MAXIN
1471            NPARMS = 0
1472            FATAL = .TRUE.
1473         END IF
1474*
1475*        Read the values of NB
1476*
1477         IF( .NOT.CBB ) THEN
1478            READ( NIN, FMT = * )( NBVAL( I ), I = 1, NPARMS )
1479            DO 70 I = 1, NPARMS
1480               IF( NBVAL( I ).LT.0 ) THEN
1481                  WRITE( NOUT, FMT = 9989 )'   NB ', NBVAL( I ), 0
1482                  FATAL = .TRUE.
1483               ELSE IF( NBVAL( I ).GT.NMAX ) THEN
1484                  WRITE( NOUT, FMT = 9988 )'   NB ', NBVAL( I ), NMAX
1485                  FATAL = .TRUE.
1486               END IF
1487   70       CONTINUE
1488            WRITE( NOUT, FMT = 9983 )'NB:   ',
1489     $         ( NBVAL( I ), I = 1, NPARMS )
1490         END IF
1491*
1492*        Read the values of NBMIN
1493*
1494         IF( NEP .OR. SEP .OR. SVD .OR. CGG ) THEN
1495            READ( NIN, FMT = * )( NBMIN( I ), I = 1, NPARMS )
1496            DO 80 I = 1, NPARMS
1497               IF( NBMIN( I ).LT.0 ) THEN
1498                  WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( I ), 0
1499                  FATAL = .TRUE.
1500               ELSE IF( NBMIN( I ).GT.NMAX ) THEN
1501                  WRITE( NOUT, FMT = 9988 )'NBMIN ', NBMIN( I ), NMAX
1502                  FATAL = .TRUE.
1503               END IF
1504   80       CONTINUE
1505            WRITE( NOUT, FMT = 9983 )'NBMIN:',
1506     $         ( NBMIN( I ), I = 1, NPARMS )
1507         ELSE
1508            DO 90 I = 1, NPARMS
1509               NBMIN( I ) = 1
1510   90       CONTINUE
1511         END IF
1512*
1513*        Read the values of NX
1514*
1515         IF( NEP .OR. SEP .OR. SVD ) THEN
1516            READ( NIN, FMT = * )( NXVAL( I ), I = 1, NPARMS )
1517            DO 100 I = 1, NPARMS
1518               IF( NXVAL( I ).LT.0 ) THEN
1519                  WRITE( NOUT, FMT = 9989 )'   NX ', NXVAL( I ), 0
1520                  FATAL = .TRUE.
1521               ELSE IF( NXVAL( I ).GT.NMAX ) THEN
1522                  WRITE( NOUT, FMT = 9988 )'   NX ', NXVAL( I ), NMAX
1523                  FATAL = .TRUE.
1524               END IF
1525  100       CONTINUE
1526            WRITE( NOUT, FMT = 9983 )'NX:   ',
1527     $         ( NXVAL( I ), I = 1, NPARMS )
1528         ELSE
1529            DO 110 I = 1, NPARMS
1530               NXVAL( I ) = 1
1531  110       CONTINUE
1532         END IF
1533*
1534*        Read the values of NSHIFT (if CGG) or NRHS (if SVD
1535*        or CBB).
1536*
1537         IF( SVD .OR. CBB .OR. CGG ) THEN
1538            READ( NIN, FMT = * )( NSVAL( I ), I = 1, NPARMS )
1539            DO 120 I = 1, NPARMS
1540               IF( NSVAL( I ).LT.0 ) THEN
1541                  WRITE( NOUT, FMT = 9989 )'   NS ', NSVAL( I ), 0
1542                  FATAL = .TRUE.
1543               ELSE IF( NSVAL( I ).GT.NMAX ) THEN
1544                  WRITE( NOUT, FMT = 9988 )'   NS ', NSVAL( I ), NMAX
1545                  FATAL = .TRUE.
1546               END IF
1547  120       CONTINUE
1548            WRITE( NOUT, FMT = 9983 )'NS:   ',
1549     $         ( NSVAL( I ), I = 1, NPARMS )
1550         ELSE
1551            DO 130 I = 1, NPARMS
1552               NSVAL( I ) = 1
1553  130       CONTINUE
1554         END IF
1555*
1556*        Read the values for MAXB.
1557*
1558         IF( CGG ) THEN
1559            READ( NIN, FMT = * )( MXBVAL( I ), I = 1, NPARMS )
1560            DO 140 I = 1, NPARMS
1561               IF( MXBVAL( I ).LT.0 ) THEN
1562                  WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( I ), 0
1563                  FATAL = .TRUE.
1564               ELSE IF( MXBVAL( I ).GT.NMAX ) THEN
1565                  WRITE( NOUT, FMT = 9988 )' MAXB ', MXBVAL( I ), NMAX
1566                  FATAL = .TRUE.
1567               END IF
1568  140       CONTINUE
1569            WRITE( NOUT, FMT = 9983 )'MAXB: ',
1570     $         ( MXBVAL( I ), I = 1, NPARMS )
1571         ELSE
1572            DO 150 I = 1, NPARMS
1573               MXBVAL( I ) = 1
1574  150       CONTINUE
1575         END IF
1576*
1577*        Read the values for INMIN.
1578*
1579         IF( NEP ) THEN
1580            READ( NIN, FMT = * )( INMIN( I ), I = 1, NPARMS )
1581            DO 540 I = 1, NPARMS
1582               IF( INMIN( I ).LT.0 ) THEN
1583                  WRITE( NOUT, FMT = 9989 )' INMIN ', INMIN( I ), 0
1584                  FATAL = .TRUE.
1585               END IF
1586  540       CONTINUE
1587            WRITE( NOUT, FMT = 9983 )'INMIN: ',
1588     $         ( INMIN( I ), I = 1, NPARMS )
1589         ELSE
1590            DO 550 I = 1, NPARMS
1591               INMIN( I ) = 1
1592  550       CONTINUE
1593         END IF
1594*
1595*        Read the values for INWIN.
1596*
1597         IF( NEP ) THEN
1598            READ( NIN, FMT = * )( INWIN( I ), I = 1, NPARMS )
1599            DO 560 I = 1, NPARMS
1600               IF( INWIN( I ).LT.0 ) THEN
1601                  WRITE( NOUT, FMT = 9989 )' INWIN ', INWIN( I ), 0
1602                  FATAL = .TRUE.
1603               END IF
1604  560       CONTINUE
1605            WRITE( NOUT, FMT = 9983 )'INWIN: ',
1606     $         ( INWIN( I ), I = 1, NPARMS )
1607         ELSE
1608            DO 570 I = 1, NPARMS
1609               INWIN( I ) = 1
1610  570       CONTINUE
1611         END IF
1612*
1613*        Read the values for INIBL.
1614*
1615         IF( NEP ) THEN
1616            READ( NIN, FMT = * )( INIBL( I ), I = 1, NPARMS )
1617            DO 580 I = 1, NPARMS
1618               IF( INIBL( I ).LT.0 ) THEN
1619                  WRITE( NOUT, FMT = 9989 )' INIBL ', INIBL( I ), 0
1620                  FATAL = .TRUE.
1621               END IF
1622  580       CONTINUE
1623            WRITE( NOUT, FMT = 9983 )'INIBL: ',
1624     $         ( INIBL( I ), I = 1, NPARMS )
1625         ELSE
1626            DO 590 I = 1, NPARMS
1627               INIBL( I ) = 1
1628  590       CONTINUE
1629         END IF
1630*
1631*        Read the values for ISHFTS.
1632*
1633         IF( NEP ) THEN
1634            READ( NIN, FMT = * )( ISHFTS( I ), I = 1, NPARMS )
1635            DO 600 I = 1, NPARMS
1636               IF( ISHFTS( I ).LT.0 ) THEN
1637                  WRITE( NOUT, FMT = 9989 )' ISHFTS ', ISHFTS( I ), 0
1638                  FATAL = .TRUE.
1639               END IF
1640  600       CONTINUE
1641            WRITE( NOUT, FMT = 9983 )'ISHFTS: ',
1642     $         ( ISHFTS( I ), I = 1, NPARMS )
1643         ELSE
1644            DO 610 I = 1, NPARMS
1645               ISHFTS( I ) = 1
1646  610       CONTINUE
1647         END IF
1648*
1649*        Read the values for IACC22.
1650*
1651         IF( NEP .OR. CGG ) THEN
1652            READ( NIN, FMT = * )( IACC22( I ), I = 1, NPARMS )
1653            DO 620 I = 1, NPARMS
1654               IF( IACC22( I ).LT.0 ) THEN
1655                  WRITE( NOUT, FMT = 9989 )' IACC22 ', IACC22( I ), 0
1656                  FATAL = .TRUE.
1657               END IF
1658  620       CONTINUE
1659            WRITE( NOUT, FMT = 9983 )'IACC22: ',
1660     $         ( IACC22( I ), I = 1, NPARMS )
1661         ELSE
1662            DO 630 I = 1, NPARMS
1663               IACC22( I ) = 1
1664  630       CONTINUE
1665         END IF
1666*
1667*        Read the values for NBCOL.
1668*
1669         IF( CGG ) THEN
1670            READ( NIN, FMT = * )( NBCOL( I ), I = 1, NPARMS )
1671            DO 160 I = 1, NPARMS
1672               IF( NBCOL( I ).LT.0 ) THEN
1673                  WRITE( NOUT, FMT = 9989 )'NBCOL ', NBCOL( I ), 0
1674                  FATAL = .TRUE.
1675               ELSE IF( NBCOL( I ).GT.NMAX ) THEN
1676                  WRITE( NOUT, FMT = 9988 )'NBCOL ', NBCOL( I ), NMAX
1677                  FATAL = .TRUE.
1678               END IF
1679  160       CONTINUE
1680            WRITE( NOUT, FMT = 9983 )'NBCOL:',
1681     $         ( NBCOL( I ), I = 1, NPARMS )
1682         ELSE
1683            DO 170 I = 1, NPARMS
1684               NBCOL( I ) = 1
1685  170       CONTINUE
1686         END IF
1687      END IF
1688*
1689*     Calculate and print the machine dependent constants.
1690*
1691      WRITE( NOUT, FMT = * )
1692      EPS = SLAMCH( 'Underflow threshold' )
1693      WRITE( NOUT, FMT = 9981 )'underflow', EPS
1694      EPS = SLAMCH( 'Overflow threshold' )
1695      WRITE( NOUT, FMT = 9981 )'overflow ', EPS
1696      EPS = SLAMCH( 'Epsilon' )
1697      WRITE( NOUT, FMT = 9981 )'precision', EPS
1698*
1699*     Read the threshold value for the test ratios.
1700*
1701      READ( NIN, FMT = * )THRESH
1702      WRITE( NOUT, FMT = 9982 )THRESH
1703      IF( SEP .OR. SVD .OR. CGG ) THEN
1704*
1705*        Read the flag that indicates whether to test LAPACK routines.
1706*
1707         READ( NIN, FMT = * )TSTCHK
1708*
1709*        Read the flag that indicates whether to test driver routines.
1710*
1711         READ( NIN, FMT = * )TSTDRV
1712      END IF
1713*
1714*     Read the flag that indicates whether to test the error exits.
1715*
1716      READ( NIN, FMT = * )TSTERR
1717*
1718*     Read the code describing how to set the random number seed.
1719*
1720      READ( NIN, FMT = * )NEWSD
1721*
1722*     If NEWSD = 2, read another line with 4 integers for the seed.
1723*
1724      IF( NEWSD.EQ.2 )
1725     $   READ( NIN, FMT = * )( IOLDSD( I ), I = 1, 4 )
1726*
1727      DO 180 I = 1, 4
1728         ISEED( I ) = IOLDSD( I )
1729  180 CONTINUE
1730*
1731      IF( FATAL ) THEN
1732         WRITE( NOUT, FMT = 9999 )
1733         STOP
1734      END IF
1735*
1736*     Read the input lines indicating the test path and its parameters.
1737*     The first three characters indicate the test path, and the number
1738*     of test matrix types must be the first nonblank item in columns
1739*     4-80.
1740*
1741  190 CONTINUE
1742*
1743      IF( .NOT.( CGX .OR. CXV ) ) THEN
1744*
1745  200    CONTINUE
1746         READ( NIN, FMT = '(A80)', END = 380 )LINE
1747         C3 = LINE( 1: 3 )
1748         LENP = LEN( LINE )
1749         I = 3
1750         ITMP = 0
1751         I1 = 0
1752  210    CONTINUE
1753         I = I + 1
1754         IF( I.GT.LENP ) THEN
1755            IF( I1.GT.0 ) THEN
1756               GO TO 240
1757            ELSE
1758               NTYPES = MAXT
1759               GO TO 240
1760            END IF
1761         END IF
1762         IF( LINE( I: I ).NE.' ' .AND. LINE( I: I ).NE.',' ) THEN
1763            I1 = I
1764            C1 = LINE( I1: I1 )
1765*
1766*        Check that a valid integer was read
1767*
1768            DO 220 K = 1, 10
1769               IF( C1.EQ.INTSTR( K: K ) ) THEN
1770                  IC = K - 1
1771                  GO TO 230
1772               END IF
1773  220       CONTINUE
1774            WRITE( NOUT, FMT = 9991 )I, LINE
1775            GO TO 200
1776  230       CONTINUE
1777            ITMP = 10*ITMP + IC
1778            GO TO 210
1779         ELSE IF( I1.GT.0 ) THEN
1780            GO TO 240
1781         ELSE
1782            GO TO 210
1783         END IF
1784  240    CONTINUE
1785         NTYPES = ITMP
1786*
1787*     Skip the tests if NTYPES is <= 0.
1788*
1789         IF( .NOT.( CEV .OR. CES .OR. CVX .OR. CSX .OR. CGV .OR.
1790     $       CGS ) .AND. NTYPES.LE.0 ) THEN
1791            WRITE( NOUT, FMT = 9990 )C3
1792            GO TO 200
1793         END IF
1794*
1795      ELSE
1796         IF( CGX )
1797     $      C3 = 'CGX'
1798         IF( CXV )
1799     $      C3 = 'CXV'
1800      END IF
1801*
1802*     Reset the random number seed.
1803*
1804      IF( NEWSD.EQ.0 ) THEN
1805         DO 250 K = 1, 4
1806            ISEED( K ) = IOLDSD( K )
1807  250    CONTINUE
1808      END IF
1809*
1810      IF( LSAMEN( 3, C3, 'CHS' ) .OR. LSAMEN( 3, C3, 'NEP' ) ) THEN
1811*
1812*        -------------------------------------
1813*        NEP:  Nonsymmetric Eigenvalue Problem
1814*        -------------------------------------
1815*        Vary the parameters
1816*           NB    = block size
1817*           NBMIN = minimum block size
1818*           NX    = crossover point
1819*           NS    = number of shifts
1820*           MAXB  = minimum submatrix size
1821*
1822         MAXTYP = 21
1823         NTYPES = MIN( MAXTYP, NTYPES )
1824         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1825         CALL XLAENV( 1, 1 )
1826         IF( TSTERR )
1827     $      CALL CERRHS( 'CHSEQR', NOUT )
1828         DO 270 I = 1, NPARMS
1829            CALL XLAENV( 1, NBVAL( I ) )
1830            CALL XLAENV( 2, NBMIN( I ) )
1831            CALL XLAENV( 3, NXVAL( I ) )
1832            CALL XLAENV(12, MAX( 11, INMIN( I ) ) )
1833            CALL XLAENV(13, INWIN( I ) )
1834            CALL XLAENV(14, INIBL( I ) )
1835            CALL XLAENV(15, ISHFTS( I ) )
1836            CALL XLAENV(16, IACC22( I ) )
1837*
1838            IF( NEWSD.EQ.0 ) THEN
1839               DO 260 K = 1, 4
1840                  ISEED( K ) = IOLDSD( K )
1841  260          CONTINUE
1842            END IF
1843            WRITE( NOUT, FMT = 9961 )C3, NBVAL( I ), NBMIN( I ),
1844     $         NXVAL( I ), MAX( 11, INMIN(I)),
1845     $         INWIN( I ), INIBL( I ), ISHFTS( I ), IACC22( I )
1846            CALL CCHKHS( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
1847     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
1848     $                   A( 1, 4 ), A( 1, 5 ), NMAX, A( 1, 6 ),
1849     $                   A( 1, 7 ), DC( 1, 1 ), DC( 1, 2 ), A( 1, 8 ),
1850     $                   A( 1, 9 ), A( 1, 10 ), A( 1, 11 ), A( 1, 12 ),
1851     $                   DC( 1, 3 ), WORK, LWORK, RWORK, IWORK, LOGWRK,
1852     $                   RESULT, INFO )
1853            IF( INFO.NE.0 )
1854     $         WRITE( NOUT, FMT = 9980 )'CCHKHS', INFO
1855  270    CONTINUE
1856*
1857      ELSE IF( LSAMEN( 3, C3, 'CST' ) .OR. LSAMEN( 3, C3, 'SEP' )
1858     $                                .OR. LSAMEN( 3, C3, 'SE2' ) ) THEN
1859*
1860*        ----------------------------------
1861*        SEP:  Symmetric Eigenvalue Problem
1862*        ----------------------------------
1863*        Vary the parameters
1864*           NB    = block size
1865*           NBMIN = minimum block size
1866*           NX    = crossover point
1867*
1868         MAXTYP = 21
1869         NTYPES = MIN( MAXTYP, NTYPES )
1870         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1871         CALL XLAENV( 1, 1 )
1872         CALL XLAENV( 9, 25 )
1873         IF( TSTERR ) THEN
1874#if defined(_OPENMP)
1875            N_THREADS = OMP_GET_MAX_THREADS()
1876            ONE_THREAD = 1
1877            CALL OMP_SET_NUM_THREADS(ONE_THREAD)
1878#endif
1879            CALL CERRST( 'CST', NOUT )
1880#if defined(_OPENMP)
1881            CALL OMP_SET_NUM_THREADS(N_THREADS)
1882#endif
1883         END IF
1884         DO 290 I = 1, NPARMS
1885            CALL XLAENV( 1, NBVAL( I ) )
1886            CALL XLAENV( 2, NBMIN( I ) )
1887            CALL XLAENV( 3, NXVAL( I ) )
1888*
1889            IF( NEWSD.EQ.0 ) THEN
1890               DO 280 K = 1, 4
1891                  ISEED( K ) = IOLDSD( K )
1892  280          CONTINUE
1893            END IF
1894            WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ),
1895     $         NXVAL( I )
1896            IF( TSTCHK ) THEN
1897               IF( LSAMEN( 3, C3, 'SE2' ) ) THEN
1898               CALL CCHKST2STG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
1899     $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ),
1900     $                      DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
1901     $                      DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
1902     $                      DR( 1, 7 ), DR( 1, 8 ), DR( 1, 9 ),
1903     $                      DR( 1, 10 ), DR( 1, 11 ), A( 1, 3 ), NMAX,
1904     $                      A( 1, 4 ), A( 1, 5 ), DC( 1, 1 ), A( 1, 6 ),
1905     $                      WORK, LWORK, RWORK, LWORK, IWORK, LIWORK,
1906     $                      RESULT, INFO )
1907               ELSE
1908               CALL CCHKST( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
1909     $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ),
1910     $                      DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
1911     $                      DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
1912     $                      DR( 1, 7 ), DR( 1, 8 ), DR( 1, 9 ),
1913     $                      DR( 1, 10 ), DR( 1, 11 ), A( 1, 3 ), NMAX,
1914     $                      A( 1, 4 ), A( 1, 5 ), DC( 1, 1 ), A( 1, 6 ),
1915     $                      WORK, LWORK, RWORK, LWORK, IWORK, LIWORK,
1916     $                      RESULT, INFO )
1917               ENDIF
1918               IF( INFO.NE.0 )
1919     $            WRITE( NOUT, FMT = 9980 )'CCHKST', INFO
1920            END IF
1921            IF( TSTDRV ) THEN
1922               IF( LSAMEN( 3, C3, 'SE2' ) ) THEN
1923               CALL CDRVST2STG( NN, NVAL, 18, DOTYPE, ISEED, THRESH,
1924     $                    NOUT, A( 1, 1 ), NMAX, DR( 1, 3 ), DR( 1, 4 ),
1925     $                    DR( 1, 5 ), DR( 1, 8 ), DR( 1, 9 ),
1926     $                    DR( 1, 10 ), A( 1, 2 ), NMAX, A( 1, 3 ),
1927     $                    DC( 1, 1 ), A( 1, 4 ), WORK, LWORK, RWORK,
1928     $                    LWORK, IWORK, LIWORK, RESULT, INFO )
1929               ELSE
1930               CALL CDRVST( NN, NVAL, 18, DOTYPE, ISEED, THRESH, NOUT,
1931     $                    A( 1, 1 ), NMAX, DR( 1, 3 ), DR( 1, 4 ),
1932     $                    DR( 1, 5 ), DR( 1, 8 ), DR( 1, 9 ),
1933     $                    DR( 1, 10 ), A( 1, 2 ), NMAX, A( 1, 3 ),
1934     $                    DC( 1, 1 ), A( 1, 4 ), WORK, LWORK, RWORK,
1935     $                    LWORK, IWORK, LIWORK, RESULT, INFO )
1936           ENDIF
1937               IF( INFO.NE.0 )
1938     $            WRITE( NOUT, FMT = 9980 )'CDRVST', INFO
1939            END IF
1940  290    CONTINUE
1941*
1942      ELSE IF( LSAMEN( 3, C3, 'CSG' ) ) THEN
1943*
1944*        ----------------------------------------------
1945*        CSG:  Hermitian Generalized Eigenvalue Problem
1946*        ----------------------------------------------
1947*        Vary the parameters
1948*           NB    = block size
1949*           NBMIN = minimum block size
1950*           NX    = crossover point
1951*
1952         MAXTYP = 21
1953         NTYPES = MIN( MAXTYP, NTYPES )
1954         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
1955         CALL XLAENV( 9, 25 )
1956         DO 310 I = 1, NPARMS
1957            CALL XLAENV( 1, NBVAL( I ) )
1958            CALL XLAENV( 2, NBMIN( I ) )
1959            CALL XLAENV( 3, NXVAL( I ) )
1960*
1961            IF( NEWSD.EQ.0 ) THEN
1962               DO 300 K = 1, 4
1963                  ISEED( K ) = IOLDSD( K )
1964  300          CONTINUE
1965            END IF
1966            WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ),
1967     $         NXVAL( I )
1968            IF( TSTCHK ) THEN
1969*               CALL CDRVSG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
1970*     $                      NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
1971*     $                      DR( 1, 3 ), A( 1, 3 ), NMAX, A( 1, 4 ),
1972*     $                      A( 1, 5 ), A( 1, 6 ), A( 1, 7 ), WORK,
1973*     $                      LWORK, RWORK, LWORK, IWORK, LIWORK, RESULT,
1974*     $                      INFO )
1975               CALL CDRVSG2STG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
1976     $                          NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
1977     $                          DR( 1, 3 ), DR( 1, 4 ), A( 1, 3 ), NMAX,
1978     $                          A( 1, 4 ), A( 1, 5 ), A( 1, 6 ),
1979     $                          A( 1, 7 ), WORK, LWORK, RWORK, LWORK,
1980     $                          IWORK, LIWORK, RESULT, INFO )
1981               IF( INFO.NE.0 )
1982     $            WRITE( NOUT, FMT = 9980 )'CDRVSG', INFO
1983            END IF
1984  310    CONTINUE
1985*
1986      ELSE IF( LSAMEN( 3, C3, 'CBD' ) .OR. LSAMEN( 3, C3, 'SVD' ) ) THEN
1987*
1988*        ----------------------------------
1989*        SVD:  Singular Value Decomposition
1990*        ----------------------------------
1991*        Vary the parameters
1992*           NB    = block size
1993*           NBMIN = minimum block size
1994*           NX    = crossover point
1995*           NRHS  = number of right hand sides
1996*
1997         MAXTYP = 16
1998         NTYPES = MIN( MAXTYP, NTYPES )
1999         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2000         CALL XLAENV( 9, 25 )
2001*
2002*        Test the error exits
2003*
2004         CALL XLAENV( 1, 1 )
2005         IF( TSTERR .AND. TSTCHK )
2006     $      CALL CERRBD( 'CBD', NOUT )
2007         IF( TSTERR .AND. TSTDRV )
2008     $      CALL CERRED( 'CBD', NOUT )
2009*
2010         DO 330 I = 1, NPARMS
2011            NRHS = NSVAL( I )
2012            CALL XLAENV( 1, NBVAL( I ) )
2013            CALL XLAENV( 2, NBMIN( I ) )
2014            CALL XLAENV( 3, NXVAL( I ) )
2015            IF( NEWSD.EQ.0 ) THEN
2016               DO 320 K = 1, 4
2017                  ISEED( K ) = IOLDSD( K )
2018  320          CONTINUE
2019            END IF
2020            WRITE( NOUT, FMT = 9995 )C3, NBVAL( I ), NBMIN( I ),
2021     $         NXVAL( I ), NRHS
2022            IF( TSTCHK ) THEN
2023               CALL CCHKBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, NRHS, ISEED,
2024     $                      THRESH, A( 1, 1 ), NMAX, DR( 1, 1 ),
2025     $                      DR( 1, 2 ), DR( 1, 3 ), DR( 1, 4 ),
2026     $                      A( 1, 2 ), NMAX, A( 1, 3 ), A( 1, 4 ),
2027     $                      A( 1, 5 ), NMAX, A( 1, 6 ), NMAX, A( 1, 7 ),
2028     $                      A( 1, 8 ), WORK, LWORK, RWORK, NOUT, INFO )
2029               IF( INFO.NE.0 )
2030     $            WRITE( NOUT, FMT = 9980 )'CCHKBD', INFO
2031            END IF
2032            IF( TSTDRV )
2033     $         CALL CDRVBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, ISEED,
2034     $                      THRESH, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX,
2035     $                      A( 1, 3 ), NMAX, A( 1, 4 ), A( 1, 5 ),
2036     $                      A( 1, 6 ), DR( 1, 1 ), DR( 1, 2 ),
2037     $                      DR( 1, 3 ), WORK, LWORK, RWORK, IWORK, NOUT,
2038     $                      INFO )
2039  330    CONTINUE
2040*
2041      ELSE IF( LSAMEN( 3, C3, 'CEV' ) ) THEN
2042*
2043*        --------------------------------------------
2044*        CEV:  Nonsymmetric Eigenvalue Problem Driver
2045*              CGEEV (eigenvalues and eigenvectors)
2046*        --------------------------------------------
2047*
2048         MAXTYP = 21
2049         NTYPES = MIN( MAXTYP, NTYPES )
2050         IF( NTYPES.LE.0 ) THEN
2051            WRITE( NOUT, FMT = 9990 )C3
2052         ELSE
2053            IF( TSTERR )
2054     $         CALL CERRED( C3, NOUT )
2055            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2056            CALL CDRVEV( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT,
2057     $                   A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ),
2058     $                   DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX,
2059     $                   A( 1, 5 ), NMAX, RESULT, WORK, LWORK, RWORK,
2060     $                   IWORK, INFO )
2061            IF( INFO.NE.0 )
2062     $         WRITE( NOUT, FMT = 9980 )'CGEEV', INFO
2063         END IF
2064         WRITE( NOUT, FMT = 9973 )
2065         GO TO 10
2066*
2067      ELSE IF( LSAMEN( 3, C3, 'CES' ) ) THEN
2068*
2069*        --------------------------------------------
2070*        CES:  Nonsymmetric Eigenvalue Problem Driver
2071*              CGEES (Schur form)
2072*        --------------------------------------------
2073*
2074         MAXTYP = 21
2075         NTYPES = MIN( MAXTYP, NTYPES )
2076         IF( NTYPES.LE.0 ) THEN
2077            WRITE( NOUT, FMT = 9990 )C3
2078         ELSE
2079            IF( TSTERR )
2080     $         CALL CERRED( C3, NOUT )
2081            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2082            CALL CDRVES( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT,
2083     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2084     $                   DC( 1, 1 ), DC( 1, 2 ), A( 1, 4 ), NMAX,
2085     $                   RESULT, WORK, LWORK, RWORK, IWORK, LOGWRK,
2086     $                   INFO )
2087            IF( INFO.NE.0 )
2088     $         WRITE( NOUT, FMT = 9980 )'CGEES', INFO
2089         END IF
2090         WRITE( NOUT, FMT = 9973 )
2091         GO TO 10
2092*
2093      ELSE IF( LSAMEN( 3, C3, 'CVX' ) ) THEN
2094*
2095*        --------------------------------------------------------------
2096*        CVX:  Nonsymmetric Eigenvalue Problem Expert Driver
2097*              CGEEVX (eigenvalues, eigenvectors and condition numbers)
2098*        --------------------------------------------------------------
2099*
2100         MAXTYP = 21
2101         NTYPES = MIN( MAXTYP, NTYPES )
2102         IF( NTYPES.LT.0 ) THEN
2103            WRITE( NOUT, FMT = 9990 )C3
2104         ELSE
2105            IF( TSTERR )
2106     $         CALL CERRED( C3, NOUT )
2107            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2108            CALL CDRVVX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN,
2109     $                   NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ),
2110     $                   DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX,
2111     $                   A( 1, 5 ), NMAX, DR( 1, 1 ), DR( 1, 2 ),
2112     $                   DR( 1, 3 ), DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ),
2113     $                   DR( 1, 7 ), DR( 1, 8 ), RESULT, WORK, LWORK,
2114     $                   RWORK, INFO )
2115            IF( INFO.NE.0 )
2116     $         WRITE( NOUT, FMT = 9980 )'CGEEVX', INFO
2117         END IF
2118         WRITE( NOUT, FMT = 9973 )
2119         GO TO 10
2120*
2121      ELSE IF( LSAMEN( 3, C3, 'CSX' ) ) THEN
2122*
2123*        ---------------------------------------------------
2124*        CSX:  Nonsymmetric Eigenvalue Problem Expert Driver
2125*              CGEESX (Schur form and condition numbers)
2126*        ---------------------------------------------------
2127*
2128         MAXTYP = 21
2129         NTYPES = MIN( MAXTYP, NTYPES )
2130         IF( NTYPES.LT.0 ) THEN
2131            WRITE( NOUT, FMT = 9990 )C3
2132         ELSE
2133            IF( TSTERR )
2134     $         CALL CERRED( C3, NOUT )
2135            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2136            CALL CDRVSX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN,
2137     $                   NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2138     $                   DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), A( 1, 4 ),
2139     $                   NMAX, A( 1, 5 ), RESULT, WORK, LWORK, RWORK,
2140     $                   LOGWRK, INFO )
2141            IF( INFO.NE.0 )
2142     $         WRITE( NOUT, FMT = 9980 )'CGEESX', INFO
2143         END IF
2144         WRITE( NOUT, FMT = 9973 )
2145         GO TO 10
2146*
2147      ELSE IF( LSAMEN( 3, C3, 'CGG' ) ) THEN
2148*
2149*        -------------------------------------------------
2150*        CGG:  Generalized Nonsymmetric Eigenvalue Problem
2151*        -------------------------------------------------
2152*        Vary the parameters
2153*           NB    = block size
2154*           NBMIN = minimum block size
2155*           NS    = number of shifts
2156*           MAXB  = minimum submatrix size
2157*           IACC22: structured matrix multiply
2158*           NBCOL = minimum column dimension for blocks
2159*
2160         MAXTYP = 26
2161         NTYPES = MIN( MAXTYP, NTYPES )
2162         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2163         CALL XLAENV(1,1)
2164         IF( TSTCHK .AND. TSTERR )
2165     $      CALL CERRGG( C3, NOUT )
2166         DO 350 I = 1, NPARMS
2167            CALL XLAENV( 1, NBVAL( I ) )
2168            CALL XLAENV( 2, NBMIN( I ) )
2169            CALL XLAENV( 4, NSVAL( I ) )
2170            CALL XLAENV( 8, MXBVAL( I ) )
2171            CALL XLAENV( 16, IACC22( I ) )
2172            CALL XLAENV( 5, NBCOL( I ) )
2173*
2174            IF( NEWSD.EQ.0 ) THEN
2175               DO 340 K = 1, 4
2176                  ISEED( K ) = IOLDSD( K )
2177  340          CONTINUE
2178            END IF
2179            WRITE( NOUT, FMT = 9996 )C3, NBVAL( I ), NBMIN( I ),
2180     $         NSVAL( I ), MXBVAL( I ), IACC22( I ), NBCOL( I )
2181            TSTDIF = .FALSE.
2182            THRSHN = 10.
2183            IF( TSTCHK ) THEN
2184               CALL CCHKGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH,
2185     $                      TSTDIF, THRSHN, NOUT, A( 1, 1 ), NMAX,
2186     $                      A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
2187     $                      A( 1, 6 ), A( 1, 7 ), A( 1, 8 ), A( 1, 9 ),
2188     $                      NMAX, A( 1, 10 ), A( 1, 11 ), A( 1, 12 ),
2189     $                      DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ),
2190     $                      DC( 1, 4 ), A( 1, 13 ), A( 1, 14 ), WORK,
2191     $                      LWORK, RWORK, LOGWRK, RESULT, INFO )
2192               IF( INFO.NE.0 )
2193     $            WRITE( NOUT, FMT = 9980 )'CCHKGG', INFO
2194            END IF
2195  350    CONTINUE
2196*
2197      ELSE IF( LSAMEN( 3, C3, 'CGS' ) ) THEN
2198*
2199*        -------------------------------------------------
2200*        CGS:  Generalized Nonsymmetric Eigenvalue Problem
2201*              CGGES (Schur form)
2202*        -------------------------------------------------
2203*
2204         MAXTYP = 26
2205         NTYPES = MIN( MAXTYP, NTYPES )
2206         IF( NTYPES.LE.0 ) THEN
2207            WRITE( NOUT, FMT = 9990 )C3
2208         ELSE
2209            IF( TSTERR )
2210     $         CALL CERRGG( C3, NOUT )
2211            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2212            CALL CDRGES( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2213     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2214     $                   A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2215     $                   DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK,
2216     $                   RESULT, LOGWRK, INFO )
2217*
2218            IF( INFO.NE.0 )
2219     $         WRITE( NOUT, FMT = 9980 )'CDRGES', INFO
2220*
2221* Blocked version
2222*
2223            CALL XLAENV(16,2)
2224            CALL CDRGES3( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2225     $                    A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2226     $                    A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2227     $                    DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK,
2228     $                    RESULT, LOGWRK, INFO )
2229*
2230            IF( INFO.NE.0 )
2231     $         WRITE( NOUT, FMT = 9980 )'CDRGES3', INFO
2232         END IF
2233         WRITE( NOUT, FMT = 9973 )
2234
2235         GO TO 10
2236*
2237      ELSE IF( CGX ) THEN
2238*
2239*        -------------------------------------------------
2240*        CGX  Generalized Nonsymmetric Eigenvalue Problem
2241*              CGGESX (Schur form and condition numbers)
2242*        -------------------------------------------------
2243*
2244         MAXTYP = 5
2245         NTYPES = MAXTYP
2246         IF( NN.LT.0 ) THEN
2247            WRITE( NOUT, FMT = 9990 )C3
2248         ELSE
2249            IF( TSTERR )
2250     $         CALL CERRGG( C3, NOUT )
2251            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2252            CALL XLAENV( 5, 2 )
2253            CALL CDRGSX( NN, NCMAX, THRESH, NIN, NOUT, A( 1, 1 ), NMAX,
2254     $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ),
2255     $                   A( 1, 6 ), DC( 1, 1 ), DC( 1, 2 ), C,
2256     $                   NCMAX*NCMAX, S, WORK, LWORK, RWORK, IWORK,
2257     $                   LIWORK, LOGWRK, INFO )
2258            IF( INFO.NE.0 )
2259     $         WRITE( NOUT, FMT = 9980 )'CDRGSX', INFO
2260         END IF
2261         WRITE( NOUT, FMT = 9973 )
2262         GO TO 10
2263*
2264      ELSE IF( LSAMEN( 3, C3, 'CGV' ) ) THEN
2265*
2266*        -------------------------------------------------
2267*        CGV:  Generalized Nonsymmetric Eigenvalue Problem
2268*              CGGEV (Eigenvalue/vector form)
2269*        -------------------------------------------------
2270*
2271         MAXTYP = 26
2272         NTYPES = MIN( MAXTYP, NTYPES )
2273         IF( NTYPES.LE.0 ) THEN
2274            WRITE( NOUT, FMT = 9990 )C3
2275         ELSE
2276            IF( TSTERR )
2277     $         CALL CERRGG( C3, NOUT )
2278            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2279            CALL CDRGEV( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2280     $                   A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2281     $                   A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2282     $                   A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ),
2283     $                   DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK,
2284     $                   RESULT, INFO )
2285            IF( INFO.NE.0 )
2286     $         WRITE( NOUT, FMT = 9980 )'CDRGEV', INFO
2287*
2288* Blocked version
2289*
2290            CALL XLAENV(16,2)
2291            CALL CDRGEV3( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT,
2292     $                    A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ),
2293     $                    A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ),
2294     $                    A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ),
2295     $                    DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK,
2296     $                    RESULT, INFO )
2297            IF( INFO.NE.0 )
2298     $           WRITE( NOUT, FMT = 9980 )'CDRGEV3', INFO
2299         END IF
2300         WRITE( NOUT, FMT = 9973 )
2301         GO TO 10
2302*
2303      ELSE IF( CXV ) THEN
2304*
2305*        -------------------------------------------------
2306*        CXV:  Generalized Nonsymmetric Eigenvalue Problem
2307*              CGGEVX (eigenvalue/vector with condition numbers)
2308*        -------------------------------------------------
2309*
2310         MAXTYP = 2
2311         NTYPES = MAXTYP
2312         IF( NN.LT.0 ) THEN
2313            WRITE( NOUT, FMT = 9990 )C3
2314         ELSE
2315            IF( TSTERR )
2316     $         CALL CERRGG( C3, NOUT )
2317            CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2318            CALL CDRGVX( NN, THRESH, NIN, NOUT, A( 1, 1 ), NMAX,
2319     $                   A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), DC( 1, 1 ),
2320     $                   DC( 1, 2 ), A( 1, 5 ), A( 1, 6 ), IWORK( 1 ),
2321     $                   IWORK( 2 ), DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ),
2322     $                   DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), WORK,
2323     $                   LWORK, RWORK, IWORK( 3 ), LIWORK-2, RESULT,
2324     $                   LOGWRK, INFO )
2325*
2326            IF( INFO.NE.0 )
2327     $         WRITE( NOUT, FMT = 9980 )'CDRGVX', INFO
2328         END IF
2329         WRITE( NOUT, FMT = 9973 )
2330         GO TO 10
2331*
2332      ELSE IF( LSAMEN( 3, C3, 'CHB' ) ) THEN
2333*
2334*        ------------------------------
2335*        CHB:  Hermitian Band Reduction
2336*        ------------------------------
2337*
2338         MAXTYP = 15
2339         NTYPES = MIN( MAXTYP, NTYPES )
2340         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2341         IF( TSTERR ) THEN
2342#if defined(_OPENMP)
2343            N_THREADS = OMP_GET_MAX_THREADS()
2344            ONE_THREAD = 1
2345            CALL OMP_SET_NUM_THREADS(ONE_THREAD)
2346#endif
2347            CALL CERRST( 'CHB', NOUT )
2348#if defined(_OPENMP)
2349            CALL OMP_SET_NUM_THREADS(N_THREADS)
2350#endif
2351         END IF
2352*         CALL CCHKHB( NN, NVAL, NK, KVAL, MAXTYP, DOTYPE, ISEED, THRESH,
2353*     $                NOUT, A( 1, 1 ), NMAX, DR( 1, 1 ), DR( 1, 2 ),
2354*     $                A( 1, 2 ), NMAX, WORK, LWORK, RWORK, RESULT,
2355*     $                INFO )
2356         CALL CCHKHB2STG( NN, NVAL, NK, KVAL, MAXTYP, DOTYPE, ISEED,
2357     $                 THRESH, NOUT, A( 1, 1 ), NMAX, DR( 1, 1 ),
2358     $                 DR( 1, 2 ), DR( 1, 3 ), DR( 1, 4 ), DR( 1, 5 ),
2359     $                 A( 1, 2 ), NMAX, WORK, LWORK, RWORK, RESULT,
2360     $                 INFO )
2361         IF( INFO.NE.0 )
2362     $      WRITE( NOUT, FMT = 9980 )'CCHKHB', INFO
2363*
2364      ELSE IF( LSAMEN( 3, C3, 'CBB' ) ) THEN
2365*
2366*        ------------------------------
2367*        CBB:  General Band Reduction
2368*        ------------------------------
2369*
2370         MAXTYP = 15
2371         NTYPES = MIN( MAXTYP, NTYPES )
2372         CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT )
2373         DO 370 I = 1, NPARMS
2374            NRHS = NSVAL( I )
2375*
2376            IF( NEWSD.EQ.0 ) THEN
2377               DO 360 K = 1, 4
2378                  ISEED( K ) = IOLDSD( K )
2379  360          CONTINUE
2380            END IF
2381            WRITE( NOUT, FMT = 9966 )C3, NRHS
2382            CALL CCHKBB( NN, MVAL, NVAL, NK, KVAL, MAXTYP, DOTYPE, NRHS,
2383     $                   ISEED, THRESH, NOUT, A( 1, 1 ), NMAX,
2384     $                   A( 1, 2 ), 2*NMAX, DR( 1, 1 ), DR( 1, 2 ),
2385     $                   A( 1, 4 ), NMAX, A( 1, 5 ), NMAX, A( 1, 6 ),
2386     $                   NMAX, A( 1, 7 ), WORK, LWORK, RWORK, RESULT,
2387     $                   INFO )
2388            IF( INFO.NE.0 )
2389     $         WRITE( NOUT, FMT = 9980 )'CCHKBB', INFO
2390  370    CONTINUE
2391*
2392      ELSE IF( LSAMEN( 3, C3, 'GLM' ) ) THEN
2393*
2394*        -----------------------------------------
2395*        GLM:  Generalized Linear Regression Model
2396*        -----------------------------------------
2397*
2398         CALL XLAENV( 1, 1 )
2399         IF( TSTERR )
2400     $      CALL CERRGG( 'GLM', NOUT )
2401         CALL CCKGLM( NN, NVAL, MVAL, PVAL, NTYPES, ISEED, THRESH, NMAX,
2402     $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X,
2403     $                WORK, DR( 1, 1 ), NIN, NOUT, INFO )
2404         IF( INFO.NE.0 )
2405     $      WRITE( NOUT, FMT = 9980 )'CCKGLM', INFO
2406*
2407      ELSE IF( LSAMEN( 3, C3, 'GQR' ) ) THEN
2408*
2409*        ------------------------------------------
2410*        GQR:  Generalized QR and RQ factorizations
2411*        ------------------------------------------
2412*
2413         CALL XLAENV( 1, 1 )
2414         IF( TSTERR )
2415     $      CALL CERRGG( 'GQR', NOUT )
2416         CALL CCKGQR( NN, MVAL, NN, PVAL, NN, NVAL, NTYPES, ISEED,
2417     $                THRESH, NMAX, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ),
2418     $                A( 1, 4 ), TAUA, B( 1, 1 ), B( 1, 2 ), B( 1, 3 ),
2419     $                B( 1, 4 ), B( 1, 5 ), TAUB, WORK, DR( 1, 1 ), NIN,
2420     $                NOUT, INFO )
2421         IF( INFO.NE.0 )
2422     $      WRITE( NOUT, FMT = 9980 )'CCKGQR', INFO
2423*
2424      ELSE IF( LSAMEN( 3, C3, 'GSV' ) ) THEN
2425*
2426*        ----------------------------------------------
2427*        GSV:  Generalized Singular Value Decomposition
2428*        ----------------------------------------------
2429*
2430         CALL XLAENV(1,1)
2431         IF( TSTERR )
2432     $      CALL CERRGG( 'GSV', NOUT )
2433         CALL CCKGSV( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
2434     $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ),
2435     $                A( 1, 3 ), B( 1, 3 ), A( 1, 4 ), ALPHA, BETA,
2436     $                B( 1, 4 ), IWORK, WORK, DR( 1, 1 ), NIN, NOUT,
2437     $                INFO )
2438         IF( INFO.NE.0 )
2439     $      WRITE( NOUT, FMT = 9980 )'CCKGSV', INFO
2440*
2441      ELSE IF( LSAMEN( 3, C3, 'CSD' ) ) THEN
2442*
2443*        ----------------------------------------------
2444*        CSD:  CS Decomposition
2445*        ----------------------------------------------
2446*
2447         CALL XLAENV(1,1)
2448         IF( TSTERR )
2449     $      CALL CERRGG( 'CSD', NOUT )
2450         CALL CCKCSD( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
2451     $                A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), A( 1, 4 ),
2452     $                A( 1, 5 ), A( 1, 6 ), RWORK, IWORK, WORK,
2453     $                DR( 1, 1 ), NIN, NOUT, INFO )
2454         IF( INFO.NE.0 )
2455     $      WRITE( NOUT, FMT = 9980 )'CCKCSD', INFO
2456*
2457      ELSE IF( LSAMEN( 3, C3, 'LSE' ) ) THEN
2458*
2459*        --------------------------------------
2460*        LSE:  Constrained Linear Least Squares
2461*        --------------------------------------
2462*
2463         CALL XLAENV( 1, 1 )
2464         IF( TSTERR )
2465     $      CALL CERRGG( 'LSE', NOUT )
2466         CALL CCKLSE( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX,
2467     $                A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X,
2468     $                WORK, DR( 1, 1 ), NIN, NOUT, INFO )
2469         IF( INFO.NE.0 )
2470     $      WRITE( NOUT, FMT = 9980 )'CCKLSE', INFO
2471      ELSE
2472         WRITE( NOUT, FMT = * )
2473         WRITE( NOUT, FMT = * )
2474         WRITE( NOUT, FMT = 9992 )C3
2475      END IF
2476      IF( .NOT.( CGX .OR. CXV ) )
2477     $   GO TO 190
2478  380 CONTINUE
2479      WRITE( NOUT, FMT = 9994 )
2480      S2 = SECOND( )
2481      WRITE( NOUT, FMT = 9993 )S2 - S1
2482*
2483      DEALLOCATE (S, STAT = AllocateStatus)
2484      DEALLOCATE (A, STAT = AllocateStatus)
2485      DEALLOCATE (B, STAT = AllocateStatus)
2486      DEALLOCATE (C, STAT = AllocateStatus)
2487      DEALLOCATE (RWORK, STAT = AllocateStatus)
2488      DEALLOCATE (WORK,  STAT = AllocateStatus)
2489*
2490 9999 FORMAT( / ' Execution not attempted due to input errors' )
2491 9997 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4 )
2492 9996 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NS =', I4,
2493     $      ', MAXB =', I4, ', IACC22 =', I4, ', NBCOL =', I4 )
2494 9995 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
2495     $      ', NRHS =', I4 )
2496 9994 FORMAT( / / ' End of tests' )
2497 9993 FORMAT( ' Total time used = ', F12.2, ' seconds', / )
2498 9992 FORMAT( 1X, A3, ':  Unrecognized path name' )
2499 9991 FORMAT( / / ' *** Invalid integer value in column ', I2,
2500     $      ' of input', ' line:', / A79 )
2501 9990 FORMAT( / / 1X, A3, ' routines were not tested' )
2502 9989 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be >=',
2503     $      I6 )
2504 9988 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be <=',
2505     $      I6 )
2506 9987 FORMAT( ' Tests of the Nonsymmetric Eigenvalue Problem routines' )
2507 9986 FORMAT( ' Tests of the Hermitian Eigenvalue Problem routines' )
2508 9985 FORMAT( ' Tests of the Singular Value Decomposition routines' )
2509 9984 FORMAT( / ' The following parameter values will be used:' )
2510 9983 FORMAT( 4X, A, 10I6, / 10X, 10I6 )
2511 9982 FORMAT( / ' Routines pass computational tests if test ratio is ',
2512     $      'less than', F8.2, / )
2513 9981 FORMAT( ' Relative machine ', A, ' is taken to be', E16.6 )
2514 9980 FORMAT( ' *** Error code from ', A, ' = ', I4 )
2515 9979 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver',
2516     $      / '    CGEEV (eigenvalues and eigevectors)' )
2517 9978 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver',
2518     $      / '    CGEES (Schur form)' )
2519 9977 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert',
2520     $      ' Driver', / '    CGEEVX (eigenvalues, eigenvectors and',
2521     $      ' condition numbers)' )
2522 9976 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert',
2523     $      ' Driver', / '    CGEESX (Schur form and condition',
2524     $      ' numbers)' )
2525 9975 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2526     $      'Problem routines' )
2527 9974 FORMAT( ' Tests of CHBTRD', / ' (reduction of a Hermitian band ',
2528     $      'matrix to real tridiagonal form)' )
2529 9973 FORMAT( / 1X, 71( '-' ) )
2530 9972 FORMAT( / ' LAPACK VERSION ', I1, '.', I1, '.', I1 )
2531 9971 FORMAT( / ' Tests of the Generalized Linear Regression Model ',
2532     $      'routines' )
2533 9970 FORMAT( / ' Tests of the Generalized QR and RQ routines' )
2534 9969 FORMAT( / ' Tests of the Generalized Singular Value',
2535     $      ' Decomposition routines' )
2536 9968 FORMAT( / ' Tests of the Linear Least Squares routines' )
2537 9967 FORMAT( ' Tests of CGBBRD', / ' (reduction of a general band ',
2538     $      'matrix to real bidiagonal form)' )
2539 9966 FORMAT( / / 1X, A3, ':  NRHS =', I4 )
2540 9965 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2541     $      'Problem Expert Driver CGGESX' )
2542 9964 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2543     $      'Problem Driver CGGES' )
2544 9963 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2545     $      'Problem Driver CGGEV' )
2546 9962 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ',
2547     $      'Problem Expert Driver CGGEVX' )
2548 9961 FORMAT( / / 1X, A3, ':  NB =', I4, ', NBMIN =', I4, ', NX =', I4,
2549     $      ', INMIN=', I4,
2550     $      ', INWIN =', I4, ', INIBL =', I4, ', ISHFTS =', I4,
2551     $      ', IACC22 =', I4)
2552 9960 FORMAT( / ' Tests of the CS Decomposition routines' )
2553*
2554*     End of CCHKEE
2555*
2556      END
2557