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