zchkee.c
Go to the documentation of this file.
00001 /* zchkee.f -- translated by f2c (version 20061008).
00002    You must link the resulting object file with libf2c:
00003         on Microsoft Windows system, link with libf2c.lib;
00004         on Linux or Unix systems, link with .../path/to/libf2c.a -lm
00005         or, if you install libf2c.a in a standard place, with -lf2c -lm
00006         -- in that order, at the end of the command line, as in
00007                 cc *.o -lf2c -lm
00008         Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
00009 
00010                 http://www.netlib.org/f2c/libf2c.zip
00011 */
00012 
00013 #include "f2c.h"
00014 #include "blaswrap.h"
00015 
00016 /* Common Block Declarations */
00017 
00018 struct {
00019     integer nproc, nshift, maxb;
00020 } cenvir_;
00021 
00022 #define cenvir_1 cenvir_
00023 
00024 struct {
00025     integer infot, nunit;
00026     logical ok, lerr;
00027 } infoc_;
00028 
00029 #define infoc_1 infoc_
00030 
00031 struct {
00032     char srnamt[32];
00033 } srnamc_;
00034 
00035 #define srnamc_1 srnamc_
00036 
00037 struct {
00038     integer selopt, seldim;
00039     logical selval[20];
00040     doublereal selwr[20], selwi[20];
00041 } sslct_;
00042 
00043 #define sslct_1 sslct_
00044 
00045 struct {
00046     integer iparms[100];
00047 } zlaenv_;
00048 
00049 #define zlaenv_1 zlaenv_
00050 
00051 /* Table of constant values */
00052 
00053 static integer c__1 = 1;
00054 static integer c__3 = 3;
00055 static integer c__5 = 5;
00056 static integer c__6 = 6;
00057 static integer c__20 = 20;
00058 static integer c__0 = 0;
00059 static integer c__132 = 132;
00060 static integer c__2 = 2;
00061 static integer c__12 = 12;
00062 static integer c__13 = 13;
00063 static integer c__14 = 14;
00064 static integer c__15 = 15;
00065 static integer c__16 = 16;
00066 static integer c__4 = 4;
00067 static integer c__8 = 8;
00068 static integer c__89760 = 89760;
00069 static integer c__9 = 9;
00070 static integer c__25 = 25;
00071 static integer c__20064 = 20064;
00072 static integer c__18 = 18;
00073 static integer c__400 = 400;
00074 static integer c__20062 = 20062;
00075 static integer c__264 = 264;
00076 
00077 /* Main program */ int MAIN__(void)
00078 {
00079     /* Initialized data */
00080 
00081     static char intstr[10] = "0123456789";
00082     static integer ioldsd[4] = { 0,0,0,1 };
00083 
00084     /* Format strings */
00085     static char fmt_9987[] = "(\002 Tests of the Nonsymmetric Eigenvalue Pro"
00086             "blem routines\002)";
00087     static char fmt_9986[] = "(\002 Tests of the Hermitian Eigenvalue Proble"
00088             "m routines\002)";
00089     static char fmt_9985[] = "(\002 Tests of the Singular Value Decompositio"
00090             "n routines\002)";
00091     static char fmt_9979[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
00092             "oblem Driver\002,/\002    ZGEEV (eigenvalues and eigevectors)"
00093             "\002)";
00094     static char fmt_9978[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
00095             "oblem Driver\002,/\002    ZGEES (Schur form)\002)";
00096     static char fmt_9977[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
00097             "oblem Expert\002,\002 Driver\002,/\002    ZGEEVX (eigenvalues, e"
00098             "igenvectors and\002,\002 condition numbers)\002)";
00099     static char fmt_9976[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
00100             "oblem Expert\002,\002 Driver\002,/\002    ZGEESX (Schur form and"
00101             " condition\002,\002 numbers)\002)";
00102     static char fmt_9975[] = "(/\002 Tests of the Generalized Nonsymmetric E"
00103             "igenvalue \002,\002Problem routines\002)";
00104     static char fmt_9964[] = "(/\002 Tests of the Generalized Nonsymmetric E"
00105             "igenvalue \002,\002Problem Driver ZGGES\002)";
00106     static char fmt_9965[] = "(/\002 Tests of the Generalized Nonsymmetric E"
00107             "igenvalue \002,\002Problem Expert Driver ZGGESX\002)";
00108     static char fmt_9963[] = "(/\002 Tests of the Generalized Nonsymmetric E"
00109             "igenvalue \002,\002Problem Driver ZGGEV\002)";
00110     static char fmt_9962[] = "(/\002 Tests of the Generalized Nonsymmetric E"
00111             "igenvalue \002,\002Problem Expert Driver ZGGEVX\002)";
00112     static char fmt_9974[] = "(\002 Tests of ZHBTRD\002,/\002 (reduction of "
00113             "a Hermitian band \002,\002matrix to real tridiagonal form)\002)";
00114     static char fmt_9967[] = "(\002 Tests of ZGBBRD\002,/\002 (reduction of "
00115             "a general band \002,\002matrix to real bidiagonal form)\002)";
00116     static char fmt_9971[] = "(/\002 Tests of the Generalized Linear Regress"
00117             "ion Model \002,\002routines\002)";
00118     static char fmt_9970[] = "(/\002 Tests of the Generalized QR and RQ rout"
00119             "ines\002)";
00120     static char fmt_9969[] = "(/\002 Tests of the Generalized Singular Valu"
00121             "e\002,\002 Decomposition routines\002)";
00122     static char fmt_9968[] = "(/\002 Tests of the Linear Least Squares routi"
00123             "nes\002)";
00124     static char fmt_9992[] = "(1x,a3,\002:  Unrecognized path name\002)";
00125     static char fmt_9972[] = "(/\002 LAPACK VERSION \002,i1,\002.\002,i1,"
00126             "\002.\002,i1)";
00127     static char fmt_9984[] = "(/\002 The following parameter values will be "
00128             "used:\002)";
00129     static char fmt_9989[] = "(\002 Invalid input value: \002,a,\002=\002,"
00130             "i6,\002; must be >=\002,i6)";
00131     static char fmt_9988[] = "(\002 Invalid input value: \002,a,\002=\002,"
00132             "i6,\002; must be <=\002,i6)";
00133     static char fmt_9983[] = "(4x,a,10i6,/10x,10i6)";
00134     static char fmt_9981[] = "(\002 Relative machine \002,a,\002 is taken to"
00135             " be\002,d16.6)";
00136     static char fmt_9982[] = "(/\002 Routines pass computational tests if te"
00137             "st ratio is \002,\002less than\002,f8.2,/)";
00138     static char fmt_9999[] = "(/\002 Execution not attempted due to input er"
00139             "rors\002)";
00140     static char fmt_9991[] = "(//\002 *** Invalid integer value in column"
00141             " \002,i2,\002 of input\002,\002 line:\002,/a79)";
00142     static char fmt_9990[] = "(//1x,a3,\002 routines were not tested\002)";
00143     static char fmt_9961[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
00144             "i4,\002, NX =\002,i4,\002, INMIN=\002,i4,\002, INWIN =\002,i4"
00145             ",\002, INIBL =\002,i4,\002, ISHFTS =\002,i4,\002, IACC22 =\002,i"
00146             "4)";
00147     static char fmt_9980[] = "(\002 *** Error code from \002,a,\002 = \002,i"
00148             "4)";
00149     static char fmt_9997[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
00150             "i4,\002, NX =\002,i4)";
00151     static char fmt_9995[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
00152             "i4,\002, NX =\002,i4,\002, NRHS =\002,i4)";
00153     static char fmt_9973[] = "(/1x,71(\002-\002))";
00154     static char fmt_9996[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
00155             "i4,\002, NS =\002,i4,\002, MAXB =\002,i4,\002, NBCOL =\002,i4)";
00156     static char fmt_9966[] = "(//1x,a3,\002:  NRHS =\002,i4)";
00157     static char fmt_9994[] = "(//\002 End of tests\002)";
00158     static char fmt_9993[] = "(\002 Total time used = \002,f12.2,\002 seco"
00159             "nds\002,/)";
00160 
00161     /* System generated locals */
00162     integer i__1, i__2, i__3, i__4;
00163     doublereal d__1;
00164     cilist ci__1;
00165 
00166     /* Builtin functions */
00167     integer s_rsfe(cilist *), do_fio(integer *, char *, ftnlen), e_rsfe(void);
00168     /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
00169     integer s_cmp(char *, char *, ftnlen, ftnlen), s_wsfe(cilist *), e_wsfe(
00170             void), s_rsle(cilist *), do_lio(integer *, integer *, char *, 
00171             ftnlen), e_rsle(void), s_wsle(cilist *), e_wsle(void);
00172     /* Subroutine */ int s_stop(char *, ftnlen);
00173     integer i_len(char *, ftnlen);
00174 
00175     /* Local variables */
00176     doublecomplex a[243936]     /* was [17424][14] */, b[87120] /* was [17424]
00177             [5] */, c__[160000] /* was [400][400] */;
00178     integer i__, k;
00179     doublereal s[17424];
00180     doublecomplex x[660];
00181     char c1[1], c3[3];
00182     integer i1;
00183     doublereal s1, s2;
00184     doublecomplex dc[792]       /* was [132][6] */;
00185     integer ic;
00186     doublereal dr[1584] /* was [132][12] */;
00187     integer nk, nn, vers_patch__, vers_major__, vers_minor__;
00188     logical zbb, glm, nep, lse, zbk, zbl, sep, gqr, zgg, zgk, zgl, svd, zhb, 
00189             gsv;
00190     doublereal eps;
00191     logical zes, zgs, zev, zgv, zgx, zsx, zvx, zxv;
00192     doublereal beta[132];
00193     char line[80];
00194     doublecomplex taua[132];
00195     integer info;
00196     char path[3];
00197     integer kval[20], lenp, mval[20], nval[20];
00198     doublecomplex taub[132];
00199     integer pval[20], itmp, nrhs;
00200     doublecomplex work[89760];
00201     integer iacc22[20];
00202     doublereal alpha[132];
00203     logical fatal;
00204     integer iseed[4], nbcol[20], inibl[20], nbval[20], nbmin[20];
00205     char vname[32];
00206     integer inmin[20], newsd, nsval[20], inwin[20], nxval[20], iwork[20064];
00207     doublereal rwork[89760];
00208     extern doublereal dlamch_(char *), dsecnd_(void);
00209     extern /* Subroutine */ int zchkbb_(integer *, integer *, integer *, 
00210             integer *, integer *, integer *, logical *, integer *, integer *, 
00211             doublereal *, integer *, doublecomplex *, integer *, 
00212             doublecomplex *, integer *, doublereal *, doublereal *, 
00213             doublecomplex *, integer *, doublecomplex *, integer *, 
00214             doublecomplex *, integer *, doublecomplex *, doublecomplex *, 
00215             integer *, doublereal *, doublereal *, integer *), alareq_(char *, 
00216              integer *, logical *, integer *, integer *, integer *), 
00217             zchkbd_(integer *, integer *, integer *, integer *, logical *, 
00218             integer *, integer *, doublereal *, doublecomplex *, integer *, 
00219             doublereal *, doublereal *, doublereal *, doublereal *, 
00220             doublecomplex *, integer *, doublecomplex *, doublecomplex *, 
00221             doublecomplex *, integer *, doublecomplex *, integer *, 
00222             doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00223             doublereal *, integer *, integer *), zchkec_(doublereal *, 
00224             logical *, integer *, integer *), zchkhb_(integer *, integer *, 
00225             integer *, integer *, integer *, logical *, integer *, doublereal 
00226             *, integer *, doublecomplex *, integer *, doublereal *, 
00227             doublereal *, doublecomplex *, integer *, doublecomplex *, 
00228             integer *, doublereal *, doublereal *, integer *), zchkbk_(
00229             integer *, integer *), zchkbl_(integer *, integer *);
00230     extern logical lsamen_(integer *, char *, char *);
00231     extern /* Subroutine */ int zchkgg_(integer *, integer *, integer *, 
00232             logical *, integer *, doublereal *, logical *, doublereal *, 
00233             integer *, doublecomplex *, integer *, doublecomplex *, 
00234             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00235 , doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00236             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00237 , doublecomplex *, doublecomplex *, doublecomplex *, 
00238             doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00239             doublereal *, logical *, doublereal *, integer *), zchkgk_(
00240             integer *, integer *), zchkgl_(integer *, integer *), ilaver_(
00241             integer *, integer *, integer *), zckglm_(integer *, integer *, 
00242             integer *, integer *, integer *, integer *, doublereal *, integer 
00243             *, doublecomplex *, doublecomplex *, doublecomplex *, 
00244             doublecomplex *, doublecomplex *, doublecomplex *, doublereal *, 
00245             integer *, integer *, integer *), zerrbd_(char *, integer *);
00246     integer mxbval[20];
00247     extern /* Subroutine */ int zchkhs_(integer *, integer *, integer *, 
00248             logical *, integer *, doublereal *, integer *, doublecomplex *, 
00249             integer *, doublecomplex *, doublecomplex *, doublecomplex *, 
00250             doublecomplex *, integer *, doublecomplex *, doublecomplex *, 
00251             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00252 , doublecomplex *, doublecomplex *, doublecomplex *, 
00253             doublecomplex *, doublecomplex *, integer *, doublereal *, 
00254             integer *, logical *, doublereal *, integer *), zcklse_(integer *, 
00255              integer *, integer *, integer *, integer *, integer *, 
00256             doublereal *, integer *, doublecomplex *, doublecomplex *, 
00257             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00258 , doublereal *, integer *, integer *, integer *), zdrvbd_(integer 
00259             *, integer *, integer *, integer *, logical *, integer *, 
00260             doublereal *, doublecomplex *, integer *, doublecomplex *, 
00261             integer *, doublecomplex *, integer *, doublecomplex *, 
00262             doublecomplex *, doublecomplex *, doublereal *, doublereal *, 
00263             doublereal *, doublecomplex *, integer *, doublereal *, integer *, 
00264              integer *, integer *);
00265     logical tstdif;
00266     doublereal thresh;
00267     extern /* Subroutine */ int xlaenv_(integer *, integer *);
00268     logical tstchk;
00269     integer nparms, ishfts[20];
00270     extern /* Subroutine */ int zckgqr_(integer *, integer *, integer *, 
00271             integer *, integer *, integer *, integer *, integer *, doublereal 
00272             *, integer *, doublecomplex *, doublecomplex *, doublecomplex *, 
00273             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00274 , doublecomplex *, doublecomplex *, doublecomplex *, 
00275             doublecomplex *, doublecomplex *, doublereal *, integer *, 
00276             integer *, integer *);
00277     logical dotype[30], logwrk[132];
00278     doublereal thrshn;
00279     extern /* Subroutine */ int zchkst_(integer *, integer *, integer *, 
00280             logical *, integer *, doublereal *, integer *, doublecomplex *, 
00281             integer *, doublecomplex *, doublereal *, doublereal *, 
00282             doublereal *, doublereal *, doublereal *, doublereal *, 
00283             doublereal *, doublereal *, doublereal *, doublereal *, 
00284             doublereal *, doublecomplex *, integer *, doublecomplex *, 
00285             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00286 , integer *, doublereal *, integer *, integer *, integer *, 
00287             doublereal *, integer *), zckgsv_(integer *, integer *, integer *, 
00288              integer *, integer *, integer *, doublereal *, integer *, 
00289             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00290 , doublecomplex *, doublecomplex *, doublecomplex *, doublereal *, 
00291              doublereal *, doublecomplex *, integer *, doublecomplex *, 
00292             doublereal *, integer *, integer *, integer *), zdrges_(integer *, 
00293              integer *, integer *, logical *, integer *, doublereal *, 
00294             integer *, doublecomplex *, integer *, doublecomplex *, 
00295             doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00296             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00297 , integer *, doublereal *, doublereal *, logical *, integer *), 
00298             zdrgev_(integer *, integer *, integer *, logical *, integer *, 
00299             doublereal *, integer *, doublecomplex *, integer *, 
00300             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00301 , integer *, doublecomplex *, doublecomplex *, integer *, 
00302             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00303 , doublecomplex *, integer *, doublereal *, doublereal *, integer 
00304             *), zdrvgg_(integer *, integer *, integer *, logical *, integer *, 
00305              doublereal *, doublereal *, integer *, doublecomplex *, integer *
00306 , doublecomplex *, doublecomplex *, doublecomplex *, 
00307             doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00308             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00309 , doublecomplex *, doublecomplex *, doublecomplex *, 
00310             doublecomplex *, integer *, doublereal *, doublereal *, integer *)
00311             , zdrves_(integer *, integer *, integer *, logical *, integer *, 
00312             doublereal *, integer *, doublecomplex *, integer *, 
00313             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00314 , doublecomplex *, integer *, doublereal *, doublecomplex *, 
00315             integer *, doublereal *, integer *, logical *, integer *);
00316     doublereal result[500];
00317     extern /* Subroutine */ int zdrvsg_(integer *, integer *, integer *, 
00318             logical *, integer *, doublereal *, integer *, doublecomplex *, 
00319             integer *, doublecomplex *, integer *, doublereal *, 
00320             doublecomplex *, integer *, doublecomplex *, doublecomplex *, 
00321             doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00322             doublereal *, integer *, integer *, integer *, doublereal *, 
00323             integer *), zdrvev_(integer *, integer *, integer *, logical *, 
00324             integer *, doublereal *, integer *, doublecomplex *, integer *, 
00325             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00326 , integer *, doublecomplex *, integer *, doublecomplex *, integer 
00327             *, doublereal *, doublecomplex *, integer *, doublereal *, 
00328             integer *, integer *), zdrgsx_(integer *, integer *, doublereal *, 
00329              integer *, integer *, doublecomplex *, integer *, doublecomplex *
00330 , doublecomplex *, doublecomplex *, doublecomplex *, 
00331             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00332 , integer *, doublereal *, doublecomplex *, integer *, doublereal 
00333             *, integer *, integer *, logical *, integer *);
00334     integer maxtyp;
00335     logical tsterr;
00336     integer ntypes;
00337     logical tstdrv;
00338     extern /* Subroutine */ int zdrgvx_(integer *, doublereal *, integer *, 
00339             integer *, doublecomplex *, integer *, doublecomplex *, 
00340             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00341 , doublecomplex *, doublecomplex *, integer *, integer *, 
00342             doublereal *, doublereal *, doublereal *, doublereal *, 
00343             doublereal *, doublereal *, doublecomplex *, integer *, 
00344             doublereal *, integer *, integer *, doublereal *, logical *, 
00345             integer *), zerred_(char *, integer *), zerrgg_(char *, 
00346             integer *), zerrhs_(char *, integer *), zerrst_(
00347             char *, integer *), zdrvst_(integer *, integer *, integer 
00348             *, logical *, integer *, doublereal *, integer *, doublecomplex *, 
00349              integer *, doublereal *, doublereal *, doublereal *, doublereal *
00350 , doublereal *, doublereal *, doublecomplex *, integer *, 
00351             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00352 , integer *, doublereal *, integer *, integer *, integer *, 
00353             doublereal *, integer *), zdrvsx_(integer *, integer *, integer *, 
00354              logical *, integer *, doublereal *, integer *, integer *, 
00355             doublecomplex *, integer *, doublecomplex *, doublecomplex *, 
00356             doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *
00357 , integer *, doublecomplex *, doublereal *, doublecomplex *, 
00358             integer *, doublereal *, logical *, integer *), zdrvvx_(integer *, 
00359              integer *, integer *, logical *, integer *, doublereal *, 
00360             integer *, integer *, doublecomplex *, integer *, doublecomplex *, 
00361              doublecomplex *, doublecomplex *, doublecomplex *, integer *, 
00362             doublecomplex *, integer *, doublecomplex *, integer *, 
00363             doublereal *, doublereal *, doublereal *, doublereal *, 
00364             doublereal *, doublereal *, doublereal *, doublereal *, 
00365             doublereal *, doublecomplex *, integer *, doublereal *, integer *)
00366             ;
00367 
00368     /* Fortran I/O blocks */
00369     static cilist io___29 = { 0, 6, 0, fmt_9987, 0 };
00370     static cilist io___30 = { 0, 6, 0, fmt_9986, 0 };
00371     static cilist io___31 = { 0, 6, 0, fmt_9985, 0 };
00372     static cilist io___32 = { 0, 6, 0, fmt_9979, 0 };
00373     static cilist io___33 = { 0, 6, 0, fmt_9978, 0 };
00374     static cilist io___34 = { 0, 6, 0, fmt_9977, 0 };
00375     static cilist io___35 = { 0, 6, 0, fmt_9976, 0 };
00376     static cilist io___36 = { 0, 6, 0, fmt_9975, 0 };
00377     static cilist io___37 = { 0, 6, 0, fmt_9964, 0 };
00378     static cilist io___38 = { 0, 6, 0, fmt_9965, 0 };
00379     static cilist io___39 = { 0, 6, 0, fmt_9963, 0 };
00380     static cilist io___40 = { 0, 6, 0, fmt_9962, 0 };
00381     static cilist io___41 = { 0, 6, 0, fmt_9974, 0 };
00382     static cilist io___42 = { 0, 6, 0, fmt_9967, 0 };
00383     static cilist io___43 = { 0, 6, 0, fmt_9971, 0 };
00384     static cilist io___44 = { 0, 6, 0, fmt_9970, 0 };
00385     static cilist io___45 = { 0, 6, 0, fmt_9969, 0 };
00386     static cilist io___46 = { 0, 6, 0, fmt_9968, 0 };
00387     static cilist io___47 = { 0, 5, 0, 0, 0 };
00388     static cilist io___50 = { 0, 6, 0, fmt_9992, 0 };
00389     static cilist io___54 = { 0, 6, 0, fmt_9972, 0 };
00390     static cilist io___55 = { 0, 6, 0, fmt_9984, 0 };
00391     static cilist io___56 = { 0, 5, 0, 0, 0 };
00392     static cilist io___58 = { 0, 6, 0, fmt_9989, 0 };
00393     static cilist io___59 = { 0, 6, 0, fmt_9988, 0 };
00394     static cilist io___60 = { 0, 5, 0, 0, 0 };
00395     static cilist io___64 = { 0, 6, 0, fmt_9989, 0 };
00396     static cilist io___65 = { 0, 6, 0, fmt_9988, 0 };
00397     static cilist io___66 = { 0, 6, 0, fmt_9983, 0 };
00398     static cilist io___67 = { 0, 5, 0, 0, 0 };
00399     static cilist io___69 = { 0, 6, 0, fmt_9989, 0 };
00400     static cilist io___70 = { 0, 6, 0, fmt_9988, 0 };
00401     static cilist io___71 = { 0, 6, 0, fmt_9983, 0 };
00402     static cilist io___72 = { 0, 5, 0, 0, 0 };
00403     static cilist io___74 = { 0, 6, 0, fmt_9989, 0 };
00404     static cilist io___75 = { 0, 6, 0, fmt_9988, 0 };
00405     static cilist io___76 = { 0, 6, 0, fmt_9983, 0 };
00406     static cilist io___77 = { 0, 6, 0, fmt_9983, 0 };
00407     static cilist io___78 = { 0, 5, 0, 0, 0 };
00408     static cilist io___80 = { 0, 5, 0, 0, 0 };
00409     static cilist io___82 = { 0, 6, 0, fmt_9989, 0 };
00410     static cilist io___83 = { 0, 6, 0, fmt_9988, 0 };
00411     static cilist io___84 = { 0, 6, 0, fmt_9983, 0 };
00412     static cilist io___85 = { 0, 5, 0, 0, 0 };
00413     static cilist io___94 = { 0, 6, 0, fmt_9989, 0 };
00414     static cilist io___95 = { 0, 6, 0, fmt_9989, 0 };
00415     static cilist io___96 = { 0, 6, 0, fmt_9989, 0 };
00416     static cilist io___97 = { 0, 6, 0, fmt_9989, 0 };
00417     static cilist io___98 = { 0, 6, 0, fmt_9989, 0 };
00418     static cilist io___99 = { 0, 6, 0, fmt_9989, 0 };
00419     static cilist io___100 = { 0, 6, 0, fmt_9989, 0 };
00420     static cilist io___101 = { 0, 6, 0, fmt_9989, 0 };
00421     static cilist io___102 = { 0, 6, 0, fmt_9983, 0 };
00422     static cilist io___103 = { 0, 6, 0, fmt_9983, 0 };
00423     static cilist io___104 = { 0, 6, 0, fmt_9983, 0 };
00424     static cilist io___105 = { 0, 6, 0, fmt_9983, 0 };
00425     static cilist io___106 = { 0, 6, 0, fmt_9983, 0 };
00426     static cilist io___107 = { 0, 6, 0, fmt_9983, 0 };
00427     static cilist io___108 = { 0, 6, 0, fmt_9983, 0 };
00428     static cilist io___109 = { 0, 6, 0, fmt_9983, 0 };
00429     static cilist io___110 = { 0, 5, 0, 0, 0 };
00430     static cilist io___113 = { 0, 6, 0, fmt_9989, 0 };
00431     static cilist io___114 = { 0, 6, 0, fmt_9989, 0 };
00432     static cilist io___115 = { 0, 6, 0, fmt_9989, 0 };
00433     static cilist io___116 = { 0, 6, 0, fmt_9989, 0 };
00434     static cilist io___117 = { 0, 6, 0, fmt_9989, 0 };
00435     static cilist io___118 = { 0, 6, 0, fmt_9983, 0 };
00436     static cilist io___119 = { 0, 6, 0, fmt_9983, 0 };
00437     static cilist io___120 = { 0, 6, 0, fmt_9983, 0 };
00438     static cilist io___121 = { 0, 6, 0, fmt_9983, 0 };
00439     static cilist io___122 = { 0, 6, 0, fmt_9983, 0 };
00440     static cilist io___123 = { 0, 5, 0, 0, 0 };
00441     static cilist io___125 = { 0, 6, 0, fmt_9989, 0 };
00442     static cilist io___126 = { 0, 6, 0, fmt_9988, 0 };
00443     static cilist io___127 = { 0, 5, 0, 0, 0 };
00444     static cilist io___128 = { 0, 6, 0, fmt_9989, 0 };
00445     static cilist io___129 = { 0, 6, 0, fmt_9988, 0 };
00446     static cilist io___130 = { 0, 6, 0, fmt_9983, 0 };
00447     static cilist io___131 = { 0, 5, 0, 0, 0 };
00448     static cilist io___132 = { 0, 6, 0, fmt_9989, 0 };
00449     static cilist io___133 = { 0, 6, 0, fmt_9988, 0 };
00450     static cilist io___134 = { 0, 6, 0, fmt_9983, 0 };
00451     static cilist io___135 = { 0, 5, 0, 0, 0 };
00452     static cilist io___136 = { 0, 6, 0, fmt_9989, 0 };
00453     static cilist io___137 = { 0, 6, 0, fmt_9988, 0 };
00454     static cilist io___138 = { 0, 6, 0, fmt_9983, 0 };
00455     static cilist io___139 = { 0, 5, 0, 0, 0 };
00456     static cilist io___140 = { 0, 6, 0, fmt_9989, 0 };
00457     static cilist io___141 = { 0, 6, 0, fmt_9988, 0 };
00458     static cilist io___142 = { 0, 6, 0, fmt_9983, 0 };
00459     static cilist io___143 = { 0, 5, 0, 0, 0 };
00460     static cilist io___144 = { 0, 6, 0, fmt_9989, 0 };
00461     static cilist io___145 = { 0, 6, 0, fmt_9988, 0 };
00462     static cilist io___146 = { 0, 6, 0, fmt_9983, 0 };
00463     static cilist io___147 = { 0, 5, 0, 0, 0 };
00464     static cilist io___148 = { 0, 6, 0, fmt_9989, 0 };
00465     static cilist io___149 = { 0, 6, 0, fmt_9983, 0 };
00466     static cilist io___150 = { 0, 5, 0, 0, 0 };
00467     static cilist io___151 = { 0, 6, 0, fmt_9989, 0 };
00468     static cilist io___152 = { 0, 6, 0, fmt_9983, 0 };
00469     static cilist io___153 = { 0, 5, 0, 0, 0 };
00470     static cilist io___154 = { 0, 6, 0, fmt_9989, 0 };
00471     static cilist io___155 = { 0, 6, 0, fmt_9983, 0 };
00472     static cilist io___156 = { 0, 5, 0, 0, 0 };
00473     static cilist io___157 = { 0, 6, 0, fmt_9989, 0 };
00474     static cilist io___158 = { 0, 6, 0, fmt_9983, 0 };
00475     static cilist io___159 = { 0, 5, 0, 0, 0 };
00476     static cilist io___160 = { 0, 6, 0, fmt_9989, 0 };
00477     static cilist io___161 = { 0, 6, 0, fmt_9983, 0 };
00478     static cilist io___162 = { 0, 5, 0, 0, 0 };
00479     static cilist io___164 = { 0, 6, 0, fmt_9989, 0 };
00480     static cilist io___165 = { 0, 6, 0, fmt_9988, 0 };
00481     static cilist io___166 = { 0, 6, 0, fmt_9983, 0 };
00482     static cilist io___167 = { 0, 6, 0, 0, 0 };
00483     static cilist io___169 = { 0, 6, 0, fmt_9981, 0 };
00484     static cilist io___170 = { 0, 6, 0, fmt_9981, 0 };
00485     static cilist io___171 = { 0, 6, 0, fmt_9981, 0 };
00486     static cilist io___172 = { 0, 5, 0, 0, 0 };
00487     static cilist io___173 = { 0, 6, 0, fmt_9982, 0 };
00488     static cilist io___174 = { 0, 5, 0, 0, 0 };
00489     static cilist io___176 = { 0, 5, 0, 0, 0 };
00490     static cilist io___178 = { 0, 5, 0, 0, 0 };
00491     static cilist io___179 = { 0, 5, 0, 0, 0 };
00492     static cilist io___181 = { 0, 5, 0, 0, 0 };
00493     static cilist io___183 = { 0, 6, 0, fmt_9999, 0 };
00494     static cilist io___192 = { 0, 6, 0, fmt_9991, 0 };
00495     static cilist io___193 = { 0, 6, 0, fmt_9990, 0 };
00496     static cilist io___196 = { 0, 6, 0, fmt_9961, 0 };
00497     static cilist io___205 = { 0, 6, 0, fmt_9980, 0 };
00498     static cilist io___206 = { 0, 6, 0, fmt_9997, 0 };
00499     static cilist io___208 = { 0, 6, 0, fmt_9980, 0 };
00500     static cilist io___209 = { 0, 6, 0, fmt_9980, 0 };
00501     static cilist io___210 = { 0, 6, 0, fmt_9997, 0 };
00502     static cilist io___211 = { 0, 6, 0, fmt_9980, 0 };
00503     static cilist io___213 = { 0, 6, 0, fmt_9995, 0 };
00504     static cilist io___214 = { 0, 6, 0, fmt_9980, 0 };
00505     static cilist io___215 = { 0, 6, 0, fmt_9990, 0 };
00506     static cilist io___216 = { 0, 6, 0, fmt_9980, 0 };
00507     static cilist io___217 = { 0, 6, 0, fmt_9973, 0 };
00508     static cilist io___218 = { 0, 6, 0, fmt_9990, 0 };
00509     static cilist io___219 = { 0, 6, 0, fmt_9980, 0 };
00510     static cilist io___220 = { 0, 6, 0, fmt_9973, 0 };
00511     static cilist io___221 = { 0, 6, 0, fmt_9990, 0 };
00512     static cilist io___222 = { 0, 6, 0, fmt_9980, 0 };
00513     static cilist io___223 = { 0, 6, 0, fmt_9973, 0 };
00514     static cilist io___224 = { 0, 6, 0, fmt_9990, 0 };
00515     static cilist io___225 = { 0, 6, 0, fmt_9980, 0 };
00516     static cilist io___226 = { 0, 6, 0, fmt_9973, 0 };
00517     static cilist io___227 = { 0, 6, 0, fmt_9996, 0 };
00518     static cilist io___230 = { 0, 6, 0, fmt_9980, 0 };
00519     static cilist io___231 = { 0, 6, 0, fmt_9980, 0 };
00520     static cilist io___232 = { 0, 6, 0, fmt_9990, 0 };
00521     static cilist io___233 = { 0, 6, 0, fmt_9980, 0 };
00522     static cilist io___234 = { 0, 6, 0, fmt_9973, 0 };
00523     static cilist io___235 = { 0, 6, 0, fmt_9990, 0 };
00524     static cilist io___238 = { 0, 6, 0, fmt_9980, 0 };
00525     static cilist io___239 = { 0, 6, 0, fmt_9973, 0 };
00526     static cilist io___240 = { 0, 6, 0, fmt_9990, 0 };
00527     static cilist io___241 = { 0, 6, 0, fmt_9980, 0 };
00528     static cilist io___242 = { 0, 6, 0, fmt_9973, 0 };
00529     static cilist io___243 = { 0, 6, 0, fmt_9990, 0 };
00530     static cilist io___244 = { 0, 6, 0, fmt_9980, 0 };
00531     static cilist io___245 = { 0, 6, 0, fmt_9973, 0 };
00532     static cilist io___246 = { 0, 6, 0, fmt_9980, 0 };
00533     static cilist io___247 = { 0, 6, 0, fmt_9966, 0 };
00534     static cilist io___248 = { 0, 6, 0, fmt_9980, 0 };
00535     static cilist io___251 = { 0, 6, 0, fmt_9980, 0 };
00536     static cilist io___254 = { 0, 6, 0, fmt_9980, 0 };
00537     static cilist io___257 = { 0, 6, 0, fmt_9980, 0 };
00538     static cilist io___258 = { 0, 6, 0, fmt_9980, 0 };
00539     static cilist io___259 = { 0, 6, 0, 0, 0 };
00540     static cilist io___260 = { 0, 6, 0, 0, 0 };
00541     static cilist io___261 = { 0, 6, 0, fmt_9992, 0 };
00542     static cilist io___262 = { 0, 6, 0, fmt_9994, 0 };
00543     static cilist io___264 = { 0, 6, 0, fmt_9993, 0 };
00544 
00545 
00546 
00547 /*  -- LAPACK test routine (version 3.1.1) -- */
00548 /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
00549 /*     February 2007 */
00550 
00551 /*  Purpose */
00552 /*  ======= */
00553 
00554 /*  ZCHKEE tests the COMPLEX*16 LAPACK subroutines for the matrix */
00555 /*  eigenvalue problem.  The test paths in this version are */
00556 
00557 /*  NEP (Nonsymmetric Eigenvalue Problem): */
00558 /*      Test ZGEHRD, ZUNGHR, ZHSEQR, ZTREVC, ZHSEIN, and ZUNMHR */
00559 
00560 /*  SEP (Hermitian Eigenvalue Problem): */
00561 /*      Test ZHETRD, ZUNGTR, ZSTEQR, ZSTERF, ZSTEIN, ZSTEDC, */
00562 /*      and drivers ZHEEV(X), ZHBEV(X), ZHPEV(X), */
00563 /*                  ZHEEVD,   ZHBEVD,   ZHPEVD */
00564 
00565 /*  SVD (Singular Value Decomposition): */
00566 /*      Test ZGEBRD, ZUNGBR, and ZBDSQR */
00567 /*      and the drivers ZGESVD, ZGESDD */
00568 
00569 /*  ZEV (Nonsymmetric Eigenvalue/eigenvector Driver): */
00570 /*      Test ZGEEV */
00571 
00572 /*  ZES (Nonsymmetric Schur form Driver): */
00573 /*      Test ZGEES */
00574 
00575 /*  ZVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver): */
00576 /*      Test ZGEEVX */
00577 
00578 /*  ZSX (Nonsymmetric Schur form Expert Driver): */
00579 /*      Test ZGEESX */
00580 
00581 /*  ZGG (Generalized Nonsymmetric Eigenvalue Problem): */
00582 /*      Test ZGGHRD, ZGGBAL, ZGGBAK, ZHGEQZ, and ZTGEVC */
00583 /*      and the driver routines ZGEGS and ZGEGV */
00584 
00585 /*  ZGS (Generalized Nonsymmetric Schur form Driver): */
00586 /*      Test ZGGES */
00587 
00588 /*  ZGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver): */
00589 /*      Test ZGGEV */
00590 
00591 /*  ZGX (Generalized Nonsymmetric Schur form Expert Driver): */
00592 /*      Test ZGGESX */
00593 
00594 /*  ZXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver): */
00595 /*      Test ZGGEVX */
00596 
00597 /*  ZSG (Hermitian Generalized Eigenvalue Problem): */
00598 /*      Test ZHEGST, ZHEGV, ZHEGVD, ZHEGVX, ZHPGST, ZHPGV, ZHPGVD, */
00599 /*      ZHPGVX, ZHBGST, ZHBGV, ZHBGVD, and ZHBGVX */
00600 
00601 /*  ZHB (Hermitian Band Eigenvalue Problem): */
00602 /*      Test ZHBTRD */
00603 
00604 /*  ZBB (Band Singular Value Decomposition): */
00605 /*      Test ZGBBRD */
00606 
00607 /*  ZEC (Eigencondition estimation): */
00608 /*      Test ZTRSYL, ZTREXC, ZTRSNA, and ZTRSEN */
00609 
00610 /*  ZBL (Balancing a general matrix) */
00611 /*      Test ZGEBAL */
00612 
00613 /*  ZBK (Back transformation on a balanced matrix) */
00614 /*      Test ZGEBAK */
00615 
00616 /*  ZGL (Balancing a matrix pair) */
00617 /*      Test ZGGBAL */
00618 
00619 /*  ZGK (Back transformation on a matrix pair) */
00620 /*      Test ZGGBAK */
00621 
00622 /*  GLM (Generalized Linear Regression Model): */
00623 /*      Tests ZGGGLM */
00624 
00625 /*  GQR (Generalized QR and RQ factorizations): */
00626 /*      Tests ZGGQRF and ZGGRQF */
00627 
00628 /*  GSV (Generalized Singular Value Decomposition): */
00629 /*      Tests ZGGSVD, ZGGSVP, ZTGSJA, ZLAGS2, ZLAPLL, and ZLAPMT */
00630 
00631 /*  LSE (Constrained Linear Least Squares): */
00632 /*      Tests ZGGLSE */
00633 
00634 /*  Each test path has a different set of inputs, but the data sets for */
00635 /*  the driver routines xEV, xES, xVX, and xSX can be concatenated in a */
00636 /*  single input file.  The first line of input should contain one of the */
00637 /*  3-character path names in columns 1-3.  The number of remaining lines */
00638 /*  depends on what is found on the first line. */
00639 
00640 /*  The number of matrix types used in testing is often controllable from */
00641 /*  the input file.  The number of matrix types for each path, and the */
00642 /*  test routine that describes them, is as follows: */
00643 
00644 /*  Path name(s)  Types    Test routine */
00645 
00646 /*  ZHS or NEP      21     ZCHKHS */
00647 /*  ZST or SEP      21     ZCHKST (routines) */
00648 /*                  18     ZDRVST (drivers) */
00649 /*  ZBD or SVD      16     ZCHKBD (routines) */
00650 /*                   5     ZDRVBD (drivers) */
00651 /*  ZEV             21     ZDRVEV */
00652 /*  ZES             21     ZDRVES */
00653 /*  ZVX             21     ZDRVVX */
00654 /*  ZSX             21     ZDRVSX */
00655 /*  ZGG             26     ZCHKGG (routines) */
00656 /*                  26     ZDRVGG (drivers) */
00657 /*  ZGS             26     ZDRGES */
00658 /*  ZGX              5     ZDRGSX */
00659 /*  ZGV             26     ZDRGEV */
00660 /*  ZXV              2     ZDRGVX */
00661 /*  ZSG             21     ZDRVSG */
00662 /*  ZHB             15     ZCHKHB */
00663 /*  ZBB             15     ZCHKBB */
00664 /*  ZEC              -     ZCHKEC */
00665 /*  ZBL              -     ZCHKBL */
00666 /*  ZBK              -     ZCHKBK */
00667 /*  ZGL              -     ZCHKGL */
00668 /*  ZGK              -     ZCHKGK */
00669 /*  GLM              8     ZCKGLM */
00670 /*  GQR              8     ZCKGQR */
00671 /*  GSV              8     ZCKGSV */
00672 /*  LSE              8     ZCKLSE */
00673 
00674 /* ----------------------------------------------------------------------- */
00675 
00676 /*  NEP input file: */
00677 
00678 /*  line 2:  NN, INTEGER */
00679 /*           Number of values of N. */
00680 
00681 /*  line 3:  NVAL, INTEGER array, dimension (NN) */
00682 /*           The values for the matrix dimension N. */
00683 
00684 /*  line 4:  NPARMS, INTEGER */
00685 /*           Number of values of the parameters NB, NBMIN, NX, NS, and */
00686 /*           MAXB. */
00687 
00688 /*  line 5:  NBVAL, INTEGER array, dimension (NPARMS) */
00689 /*           The values for the blocksize NB. */
00690 
00691 /*  line 6:  NBMIN, INTEGER array, dimension (NPARMS) */
00692 /*           The values for the minimum blocksize NBMIN. */
00693 
00694 /*  line 7:  NXVAL, INTEGER array, dimension (NPARMS) */
00695 /*           The values for the crossover point NX. */
00696 
00697 /*  line 8:  INMIN, INTEGER array, dimension (NPARMS) */
00698 /*           LAHQR vs TTQRE crossover point, >= 11 */
00699 
00700 /*  line 9:  INWIN, INTEGER array, dimension (NPARMS) */
00701 /*           recommended deflation window size */
00702 
00703 /*  line 10: INIBL, INTEGER array, dimension (NPARMS) */
00704 /*           nibble crossover point */
00705 
00706 /*  line 11:  ISHFTS, INTEGER array, dimension (NPARMS) */
00707 /*           number of simultaneous shifts) */
00708 
00709 /*  line 12:  IACC22, INTEGER array, dimension (NPARMS) */
00710 /*           select structured matrix multiply: 0, 1 or 2) */
00711 
00712 /*  line 13: THRESH */
00713 /*           Threshold value for the test ratios.  Information will be */
00714 /*           printed about each test for which the test ratio is greater */
00715 /*           than or equal to the threshold.  To have all of the test */
00716 /*           ratios printed, use THRESH = 0.0 . */
00717 
00718 /*  line 14: NEWSD, INTEGER */
00719 /*           A code indicating how to set the random number seed. */
00720 /*           = 0:  Set the seed to a default value before each run */
00721 /*           = 1:  Initialize the seed to a default value only before the */
00722 /*                 first run */
00723 /*           = 2:  Like 1, but use the seed values on the next line */
00724 
00725 /*  If line 14 was 2: */
00726 
00727 /*  line 15: INTEGER array, dimension (4) */
00728 /*           Four integer values for the random number seed. */
00729 
00730 /*  lines 15-EOF:  The remaining lines occur in sets of 1 or 2 and allow */
00731 /*           the user to specify the matrix types.  Each line contains */
00732 /*           a 3-character path name in columns 1-3, and the number */
00733 /*           of matrix types must be the first nonblank item in columns */
00734 /*           4-80.  If the number of matrix types is at least 1 but is */
00735 /*           less than the maximum number of possible types, a second */
00736 /*           line will be read to get the numbers of the matrix types to */
00737 /*           be used.  For example, */
00738 /*  NEP 21 */
00739 /*           requests all of the matrix types for the nonsymmetric */
00740 /*           eigenvalue problem, while */
00741 /*  NEP  4 */
00742 /*  9 10 11 12 */
00743 /*           requests only matrices of type 9, 10, 11, and 12. */
00744 
00745 /*           The valid 3-character path names are 'NEP' or 'ZHS' for the */
00746 /*           nonsymmetric eigenvalue routines. */
00747 
00748 /* ----------------------------------------------------------------------- */
00749 
00750 /*  SEP or ZSG input file: */
00751 
00752 /*  line 2:  NN, INTEGER */
00753 /*           Number of values of N. */
00754 
00755 /*  line 3:  NVAL, INTEGER array, dimension (NN) */
00756 /*           The values for the matrix dimension N. */
00757 
00758 /*  line 4:  NPARMS, INTEGER */
00759 /*           Number of values of the parameters NB, NBMIN, and NX. */
00760 
00761 /*  line 5:  NBVAL, INTEGER array, dimension (NPARMS) */
00762 /*           The values for the blocksize NB. */
00763 
00764 /*  line 6:  NBMIN, INTEGER array, dimension (NPARMS) */
00765 /*           The values for the minimum blocksize NBMIN. */
00766 
00767 /*  line 7:  NXVAL, INTEGER array, dimension (NPARMS) */
00768 /*           The values for the crossover point NX. */
00769 
00770 /*  line 8:  THRESH */
00771 /*           Threshold value for the test ratios.  Information will be */
00772 /*           printed about each test for which the test ratio is greater */
00773 /*           than or equal to the threshold. */
00774 
00775 /*  line 9:  TSTCHK, LOGICAL */
00776 /*           Flag indicating whether or not to test the LAPACK routines. */
00777 
00778 /*  line 10: TSTDRV, LOGICAL */
00779 /*           Flag indicating whether or not to test the driver routines. */
00780 
00781 /*  line 11: TSTERR, LOGICAL */
00782 /*           Flag indicating whether or not to test the error exits for */
00783 /*           the LAPACK routines and driver routines. */
00784 
00785 /*  line 12: NEWSD, INTEGER */
00786 /*           A code indicating how to set the random number seed. */
00787 /*           = 0:  Set the seed to a default value before each run */
00788 /*           = 1:  Initialize the seed to a default value only before the */
00789 /*                 first run */
00790 /*           = 2:  Like 1, but use the seed values on the next line */
00791 
00792 /*  If line 12 was 2: */
00793 
00794 /*  line 13: INTEGER array, dimension (4) */
00795 /*           Four integer values for the random number seed. */
00796 
00797 /*  lines 13-EOF:  Lines specifying matrix types, as for NEP. */
00798 /*           The valid 3-character path names are 'SEP' or 'ZST' for the */
00799 /*           Hermitian eigenvalue routines and driver routines, and */
00800 /*           'ZSG' for the routines for the Hermitian generalized */
00801 /*           eigenvalue problem. */
00802 
00803 /* ----------------------------------------------------------------------- */
00804 
00805 /*  SVD input file: */
00806 
00807 /*  line 2:  NN, INTEGER */
00808 /*           Number of values of M and N. */
00809 
00810 /*  line 3:  MVAL, INTEGER array, dimension (NN) */
00811 /*           The values for the matrix row dimension M. */
00812 
00813 /*  line 4:  NVAL, INTEGER array, dimension (NN) */
00814 /*           The values for the matrix column dimension N. */
00815 
00816 /*  line 5:  NPARMS, INTEGER */
00817 /*           Number of values of the parameter NB, NBMIN, NX, and NRHS. */
00818 
00819 /*  line 6:  NBVAL, INTEGER array, dimension (NPARMS) */
00820 /*           The values for the blocksize NB. */
00821 
00822 /*  line 7:  NBMIN, INTEGER array, dimension (NPARMS) */
00823 /*           The values for the minimum blocksize NBMIN. */
00824 
00825 /*  line 8:  NXVAL, INTEGER array, dimension (NPARMS) */
00826 /*           The values for the crossover point NX. */
00827 
00828 /*  line 9:  NSVAL, INTEGER array, dimension (NPARMS) */
00829 /*           The values for the number of right hand sides NRHS. */
00830 
00831 /*  line 10: THRESH */
00832 /*           Threshold value for the test ratios.  Information will be */
00833 /*           printed about each test for which the test ratio is greater */
00834 /*           than or equal to the threshold. */
00835 
00836 /*  line 11: TSTCHK, LOGICAL */
00837 /*           Flag indicating whether or not to test the LAPACK routines. */
00838 
00839 /*  line 12: TSTDRV, LOGICAL */
00840 /*           Flag indicating whether or not to test the driver routines. */
00841 
00842 /*  line 13: TSTERR, LOGICAL */
00843 /*           Flag indicating whether or not to test the error exits for */
00844 /*           the LAPACK routines and driver routines. */
00845 
00846 /*  line 14: NEWSD, INTEGER */
00847 /*           A code indicating how to set the random number seed. */
00848 /*           = 0:  Set the seed to a default value before each run */
00849 /*           = 1:  Initialize the seed to a default value only before the */
00850 /*                 first run */
00851 /*           = 2:  Like 1, but use the seed values on the next line */
00852 
00853 /*  If line 14 was 2: */
00854 
00855 /*  line 15: INTEGER array, dimension (4) */
00856 /*           Four integer values for the random number seed. */
00857 
00858 /*  lines 15-EOF:  Lines specifying matrix types, as for NEP. */
00859 /*           The 3-character path names are 'SVD' or 'ZBD' for both the */
00860 /*           SVD routines and the SVD driver routines. */
00861 
00862 /* ----------------------------------------------------------------------- */
00863 
00864 /*  ZEV and ZES data files: */
00865 
00866 /*  line 1:  'ZEV' or 'ZES' in columns 1 to 3. */
00867 
00868 /*  line 2:  NSIZES, INTEGER */
00869 /*           Number of sizes of matrices to use. Should be at least 0 */
00870 /*           and at most 20. If NSIZES = 0, no testing is done */
00871 /*           (although the remaining  3 lines are still read). */
00872 
00873 /*  line 3:  NN, INTEGER array, dimension(NSIZES) */
00874 /*           Dimensions of matrices to be tested. */
00875 
00876 /*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
00877 /*           These integer parameters determine how blocking is done */
00878 /*           (see ILAENV for details) */
00879 /*           NB     : block size */
00880 /*           NBMIN  : minimum block size */
00881 /*           NX     : minimum dimension for blocking */
00882 /*           NS     : number of shifts in xHSEQR */
00883 /*           NBCOL  : minimum column dimension for blocking */
00884 
00885 /*  line 5:  THRESH, REAL */
00886 /*           The test threshold against which computed residuals are */
00887 /*           compared. Should generally be in the range from 10. to 20. */
00888 /*           If it is 0., all test case data will be printed. */
00889 
00890 /*  line 6:  NEWSD, INTEGER */
00891 /*           A code indicating how to set the random number seed. */
00892 /*           = 0:  Set the seed to a default value before each run */
00893 /*           = 1:  Initialize the seed to a default value only before the */
00894 /*                 first run */
00895 /*           = 2:  Like 1, but use the seed values on the next line */
00896 
00897 /*  If line 6 was 2: */
00898 
00899 /*  line 7:  INTEGER array, dimension (4) */
00900 /*           Four integer values for the random number seed. */
00901 
00902 /*  lines 8 and following:  Lines specifying matrix types, as for NEP. */
00903 /*           The 3-character path name is 'ZEV' to test CGEEV, or */
00904 /*           'ZES' to test CGEES. */
00905 
00906 /* ----------------------------------------------------------------------- */
00907 
00908 /*  The ZVX data has two parts. The first part is identical to ZEV, */
00909 /*  and the second part consists of test matrices with precomputed */
00910 /*  solutions. */
00911 
00912 /*  line 1:  'ZVX' in columns 1-3. */
00913 
00914 /*  line 2:  NSIZES, INTEGER */
00915 /*           If NSIZES = 0, no testing of randomly generated examples */
00916 /*           is done, but any precomputed examples are tested. */
00917 
00918 /*  line 3:  NN, INTEGER array, dimension(NSIZES) */
00919 
00920 /*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
00921 
00922 /*  line 5:  THRESH, REAL */
00923 
00924 /*  line 6:  NEWSD, INTEGER */
00925 
00926 /*  If line 6 was 2: */
00927 
00928 /*  line 7:  INTEGER array, dimension (4) */
00929 
00930 /*  lines 8 and following: The first line contains 'ZVX' in columns 1-3 */
00931 /*           followed by the number of matrix types, possibly with */
00932 /*           a second line to specify certain matrix types. */
00933 /*           If the number of matrix types = 0, no testing of randomly */
00934 /*           generated examples is done, but any precomputed examples */
00935 /*           are tested. */
00936 
00937 /*  remaining lines : Each matrix is stored on 1+N+N**2 lines, where N is */
00938 /*           its dimension. The first line contains the dimension N and */
00939 /*           ISRT (two integers). ISRT indicates whether the last N lines */
00940 /*           are sorted by increasing real part of the eigenvalue */
00941 /*           (ISRT=0) or by increasing imaginary part (ISRT=1). The next */
00942 /*           N**2 lines contain the matrix rowwise, one entry per line. */
00943 /*           The last N lines correspond to each eigenvalue. Each of */
00944 /*           these last N lines contains 4 real values: the real part of */
00945 /*           the eigenvalues, the imaginary part of the eigenvalue, the */
00946 /*           reciprocal condition number of the eigenvalues, and the */
00947 /*           reciprocal condition number of the vector eigenvector. The */
00948 /*           end of data is indicated by dimension N=0. Even if no data */
00949 /*           is to be tested, there must be at least one line containing */
00950 /*           N=0. */
00951 
00952 /* ----------------------------------------------------------------------- */
00953 
00954 /*  The ZSX data is like ZVX. The first part is identical to ZEV, and the */
00955 /*  second part consists of test matrices with precomputed solutions. */
00956 
00957 /*  line 1:  'ZSX' in columns 1-3. */
00958 
00959 /*  line 2:  NSIZES, INTEGER */
00960 /*           If NSIZES = 0, no testing of randomly generated examples */
00961 /*           is done, but any precomputed examples are tested. */
00962 
00963 /*  line 3:  NN, INTEGER array, dimension(NSIZES) */
00964 
00965 /*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
00966 
00967 /*  line 5:  THRESH, REAL */
00968 
00969 /*  line 6:  NEWSD, INTEGER */
00970 
00971 /*  If line 6 was 2: */
00972 
00973 /*  line 7:  INTEGER array, dimension (4) */
00974 
00975 /*  lines 8 and following: The first line contains 'ZSX' in columns 1-3 */
00976 /*           followed by the number of matrix types, possibly with */
00977 /*           a second line to specify certain matrix types. */
00978 /*           If the number of matrix types = 0, no testing of randomly */
00979 /*           generated examples is done, but any precomputed examples */
00980 /*           are tested. */
00981 
00982 /*  remaining lines : Each matrix is stored on 3+N**2 lines, where N is */
00983 /*           its dimension. The first line contains the dimension N, the */
00984 /*           dimension M of an invariant subspace, and ISRT. The second */
00985 /*           line contains M integers, identifying the eigenvalues in the */
00986 /*           invariant subspace (by their position in a list of */
00987 /*           eigenvalues ordered by increasing real part (if ISRT=0) or */
00988 /*           by increasing imaginary part (if ISRT=1)). The next N**2 */
00989 /*           lines contain the matrix rowwise. The last line contains the */
00990 /*           reciprocal condition number for the average of the selected */
00991 /*           eigenvalues, and the reciprocal condition number for the */
00992 /*           corresponding right invariant subspace. The end of data in */
00993 /*           indicated by a line containing N=0, M=0, and ISRT = 0.  Even */
00994 /*           if no data is to be tested, there must be at least one line */
00995 /*           containing N=0, M=0 and ISRT=0. */
00996 
00997 /* ----------------------------------------------------------------------- */
00998 
00999 /*  ZGG input file: */
01000 
01001 /*  line 2:  NN, INTEGER */
01002 /*           Number of values of N. */
01003 
01004 /*  line 3:  NVAL, INTEGER array, dimension (NN) */
01005 /*           The values for the matrix dimension N. */
01006 
01007 /*  line 4:  NPARMS, INTEGER */
01008 /*           Number of values of the parameters NB, NBMIN, NBCOL, NS, and */
01009 /*           MAXB. */
01010 
01011 /*  line 5:  NBVAL, INTEGER array, dimension (NPARMS) */
01012 /*           The values for the blocksize NB. */
01013 
01014 /*  line 6:  NBMIN, INTEGER array, dimension (NPARMS) */
01015 /*           The values for NBMIN, the minimum row dimension for blocks. */
01016 
01017 /*  line 7:  NSVAL, INTEGER array, dimension (NPARMS) */
01018 /*           The values for the number of shifts. */
01019 
01020 /*  line 8:  MXBVAL, INTEGER array, dimension (NPARMS) */
01021 /*           The values for MAXB, used in determining minimum blocksize. */
01022 
01023 /*  line 9:  NBCOL, INTEGER array, dimension (NPARMS) */
01024 /*           The values for NBCOL, the minimum column dimension for */
01025 /*           blocks. */
01026 
01027 /*  line 10: THRESH */
01028 /*           Threshold value for the test ratios.  Information will be */
01029 /*           printed about each test for which the test ratio is greater */
01030 /*           than or equal to the threshold. */
01031 
01032 /*  line 11: TSTCHK, LOGICAL */
01033 /*           Flag indicating whether or not to test the LAPACK routines. */
01034 
01035 /*  line 12: TSTDRV, LOGICAL */
01036 /*           Flag indicating whether or not to test the driver routines. */
01037 
01038 /*  line 13: TSTERR, LOGICAL */
01039 /*           Flag indicating whether or not to test the error exits for */
01040 /*           the LAPACK routines and driver routines. */
01041 
01042 /*  line 14: NEWSD, INTEGER */
01043 /*           A code indicating how to set the random number seed. */
01044 /*           = 0:  Set the seed to a default value before each run */
01045 /*           = 1:  Initialize the seed to a default value only before the */
01046 /*                 first run */
01047 /*           = 2:  Like 1, but use the seed values on the next line */
01048 
01049 /*  If line 14 was 2: */
01050 
01051 /*  line 15: INTEGER array, dimension (4) */
01052 /*           Four integer values for the random number seed. */
01053 
01054 /*  lines 16-EOF:  Lines specifying matrix types, as for NEP. */
01055 /*           The 3-character path name is 'ZGG' for the generalized */
01056 /*           eigenvalue problem routines and driver routines. */
01057 
01058 /* ----------------------------------------------------------------------- */
01059 
01060 /*  ZGS and ZGV input files: */
01061 
01062 /*  line 1:  'ZGS' or 'ZGV' in columns 1 to 3. */
01063 
01064 /*  line 2:  NN, INTEGER */
01065 /*           Number of values of N. */
01066 
01067 /*  line 3:  NVAL, INTEGER array, dimension(NN) */
01068 /*           Dimensions of matrices to be tested. */
01069 
01070 /*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
01071 /*           These integer parameters determine how blocking is done */
01072 /*           (see ILAENV for details) */
01073 /*           NB     : block size */
01074 /*           NBMIN  : minimum block size */
01075 /*           NX     : minimum dimension for blocking */
01076 /*           NS     : number of shifts in xHGEQR */
01077 /*           NBCOL  : minimum column dimension for blocking */
01078 
01079 /*  line 5:  THRESH, REAL */
01080 /*           The test threshold against which computed residuals are */
01081 /*           compared. Should generally be in the range from 10. to 20. */
01082 /*           If it is 0., all test case data will be printed. */
01083 
01084 /*  line 6:  TSTERR, LOGICAL */
01085 /*           Flag indicating whether or not to test the error exits. */
01086 
01087 /*  line 7:  NEWSD, INTEGER */
01088 /*           A code indicating how to set the random number seed. */
01089 /*           = 0:  Set the seed to a default value before each run */
01090 /*           = 1:  Initialize the seed to a default value only before the */
01091 /*                 first run */
01092 /*           = 2:  Like 1, but use the seed values on the next line */
01093 
01094 /*  If line 17 was 2: */
01095 
01096 /*  line 7:  INTEGER array, dimension (4) */
01097 /*           Four integer values for the random number seed. */
01098 
01099 /*  lines 7-EOF:  Lines specifying matrix types, as for NEP. */
01100 /*           The 3-character path name is 'ZGS' for the generalized */
01101 /*           eigenvalue problem routines and driver routines. */
01102 
01103 /* ----------------------------------------------------------------------- */
01104 
01105 /*  ZGX input file: */
01106 /*  line 1:  'ZGX' in columns 1 to 3. */
01107 
01108 /*  line 2:  N, INTEGER */
01109 /*           Value of N. */
01110 
01111 /*  line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
01112 /*           These integer parameters determine how blocking is done */
01113 /*           (see ILAENV for details) */
01114 /*           NB     : block size */
01115 /*           NBMIN  : minimum block size */
01116 /*           NX     : minimum dimension for blocking */
01117 /*           NS     : number of shifts in xHGEQR */
01118 /*           NBCOL  : minimum column dimension for blocking */
01119 
01120 /*  line 4:  THRESH, REAL */
01121 /*           The test threshold against which computed residuals are */
01122 /*           compared. Should generally be in the range from 10. to 20. */
01123 /*           Information will be printed about each test for which the */
01124 /*           test ratio is greater than or equal to the threshold. */
01125 
01126 /*  line 5:  TSTERR, LOGICAL */
01127 /*           Flag indicating whether or not to test the error exits for */
01128 /*           the LAPACK routines and driver routines. */
01129 
01130 /*  line 6:  NEWSD, INTEGER */
01131 /*           A code indicating how to set the random number seed. */
01132 /*           = 0:  Set the seed to a default value before each run */
01133 /*           = 1:  Initialize the seed to a default value only before the */
01134 /*                 first run */
01135 /*           = 2:  Like 1, but use the seed values on the next line */
01136 
01137 /*  If line 6 was 2: */
01138 
01139 /*  line 7: INTEGER array, dimension (4) */
01140 /*           Four integer values for the random number seed. */
01141 
01142 /*  If line 2 was 0: */
01143 
01144 /*  line 7-EOF: Precomputed examples are tested. */
01145 
01146 /*  remaining lines : Each example is stored on 3+2*N*N lines, where N is */
01147 /*           its dimension. The first line contains the dimension (a */
01148 /*           single integer).  The next line contains an integer k such */
01149 /*           that only the last k eigenvalues will be selected and appear */
01150 /*           in the leading diagonal blocks of $A$ and $B$. The next N*N */
01151 /*           lines contain the matrix A, one element per line. The next N*N */
01152 /*           lines contain the matrix B. The last line contains the */
01153 /*           reciprocal of the eigenvalue cluster condition number and the */
01154 /*           reciprocal of the deflating subspace (associated with the */
01155 /*           selected eigencluster) condition number.  The end of data is */
01156 /*           indicated by dimension N=0.  Even if no data is to be tested, */
01157 /*           there must be at least one line containing N=0. */
01158 
01159 /* ----------------------------------------------------------------------- */
01160 
01161 /*  ZXV input files: */
01162 /*  line 1:  'ZXV' in columns 1 to 3. */
01163 
01164 /*  line 2:  N, INTEGER */
01165 /*           Value of N. */
01166 
01167 /*  line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
01168 /*           These integer parameters determine how blocking is done */
01169 /*           (see ILAENV for details) */
01170 /*           NB     : block size */
01171 /*           NBMIN  : minimum block size */
01172 /*           NX     : minimum dimension for blocking */
01173 /*           NS     : number of shifts in xHGEQR */
01174 /*           NBCOL  : minimum column dimension for blocking */
01175 
01176 /*  line 4:  THRESH, REAL */
01177 /*           The test threshold against which computed residuals are */
01178 /*           compared. Should generally be in the range from 10. to 20. */
01179 /*           Information will be printed about each test for which the */
01180 /*           test ratio is greater than or equal to the threshold. */
01181 
01182 /*  line 5:  TSTERR, LOGICAL */
01183 /*           Flag indicating whether or not to test the error exits for */
01184 /*           the LAPACK routines and driver routines. */
01185 
01186 /*  line 6:  NEWSD, INTEGER */
01187 /*           A code indicating how to set the random number seed. */
01188 /*           = 0:  Set the seed to a default value before each run */
01189 /*           = 1:  Initialize the seed to a default value only before the */
01190 /*                 first run */
01191 /*           = 2:  Like 1, but use the seed values on the next line */
01192 
01193 /*  If line 6 was 2: */
01194 
01195 /*  line 7: INTEGER array, dimension (4) */
01196 /*           Four integer values for the random number seed. */
01197 
01198 /*  If line 2 was 0: */
01199 
01200 /*  line 7-EOF: Precomputed examples are tested. */
01201 
01202 /*  remaining lines : Each example is stored on 3+2*N*N lines, where N is */
01203 /*           its dimension. The first line contains the dimension (a */
01204 /*           single integer). The next N*N lines contain the matrix A, one */
01205 /*           element per line. The next N*N lines contain the matrix B. */
01206 /*           The next line contains the reciprocals of the eigenvalue */
01207 /*           condition numbers.  The last line contains the reciprocals of */
01208 /*           the eigenvector condition numbers.  The end of data is */
01209 /*           indicated by dimension N=0.  Even if no data is to be tested, */
01210 /*           there must be at least one line containing N=0. */
01211 
01212 /* ----------------------------------------------------------------------- */
01213 
01214 /*  ZHB input file: */
01215 
01216 /*  line 2:  NN, INTEGER */
01217 /*           Number of values of N. */
01218 
01219 /*  line 3:  NVAL, INTEGER array, dimension (NN) */
01220 /*           The values for the matrix dimension N. */
01221 
01222 /*  line 4:  NK, INTEGER */
01223 /*           Number of values of K. */
01224 
01225 /*  line 5:  KVAL, INTEGER array, dimension (NK) */
01226 /*           The values for the matrix dimension K. */
01227 
01228 /*  line 6:  THRESH */
01229 /*           Threshold value for the test ratios.  Information will be */
01230 /*           printed about each test for which the test ratio is greater */
01231 /*           than or equal to the threshold. */
01232 
01233 /*  line 7:  NEWSD, INTEGER */
01234 /*           A code indicating how to set the random number seed. */
01235 /*           = 0:  Set the seed to a default value before each run */
01236 /*           = 1:  Initialize the seed to a default value only before the */
01237 /*                 first run */
01238 /*           = 2:  Like 1, but use the seed values on the next line */
01239 
01240 /*  If line 7 was 2: */
01241 
01242 /*  line 8:  INTEGER array, dimension (4) */
01243 /*           Four integer values for the random number seed. */
01244 
01245 /*  lines 8-EOF:  Lines specifying matrix types, as for NEP. */
01246 /*           The 3-character path name is 'ZHB'. */
01247 
01248 /* ----------------------------------------------------------------------- */
01249 
01250 /*  ZBB input file: */
01251 
01252 /*  line 2:  NN, INTEGER */
01253 /*           Number of values of M and N. */
01254 
01255 /*  line 3:  MVAL, INTEGER array, dimension (NN) */
01256 /*           The values for the matrix row dimension M. */
01257 
01258 /*  line 4:  NVAL, INTEGER array, dimension (NN) */
01259 /*           The values for the matrix column dimension N. */
01260 
01261 /*  line 4:  NK, INTEGER */
01262 /*           Number of values of K. */
01263 
01264 /*  line 5:  KVAL, INTEGER array, dimension (NK) */
01265 /*           The values for the matrix bandwidth K. */
01266 
01267 /*  line 6:  NPARMS, INTEGER */
01268 /*           Number of values of the parameter NRHS */
01269 
01270 /*  line 7:  NSVAL, INTEGER array, dimension (NPARMS) */
01271 /*           The values for the number of right hand sides NRHS. */
01272 
01273 /*  line 8:  THRESH */
01274 /*           Threshold value for the test ratios.  Information will be */
01275 /*           printed about each test for which the test ratio is greater */
01276 /*           than or equal to the threshold. */
01277 
01278 /*  line 9:  NEWSD, INTEGER */
01279 /*           A code indicating how to set the random number seed. */
01280 /*           = 0:  Set the seed to a default value before each run */
01281 /*           = 1:  Initialize the seed to a default value only before the */
01282 /*                 first run */
01283 /*           = 2:  Like 1, but use the seed values on the next line */
01284 
01285 /*  If line 9 was 2: */
01286 
01287 /*  line 10: INTEGER array, dimension (4) */
01288 /*           Four integer values for the random number seed. */
01289 
01290 /*  lines 10-EOF:  Lines specifying matrix types, as for SVD. */
01291 /*           The 3-character path name is 'ZBB'. */
01292 
01293 /* ----------------------------------------------------------------------- */
01294 
01295 /*  ZEC input file: */
01296 
01297 /*  line  2: THRESH, REAL */
01298 /*           Threshold value for the test ratios.  Information will be */
01299 /*           printed about each test for which the test ratio is greater */
01300 /*           than or equal to the threshold. */
01301 
01302 /*  lines  3-EOF: */
01303 
01304 /*  Input for testing the eigencondition routines consists of a set of */
01305 /*  specially constructed test cases and their solutions.  The data */
01306 /*  format is not intended to be modified by the user. */
01307 
01308 /* ----------------------------------------------------------------------- */
01309 
01310 /*  ZBL and ZBK input files: */
01311 
01312 /*  line 1:  'ZBL' in columns 1-3 to test CGEBAL, or 'ZBK' in */
01313 /*           columns 1-3 to test CGEBAK. */
01314 
01315 /*  The remaining lines consist of specially constructed test cases. */
01316 
01317 /* ----------------------------------------------------------------------- */
01318 
01319 /*  ZGL and ZGK input files: */
01320 
01321 /*  line 1:  'ZGL' in columns 1-3 to test ZGGBAL, or 'ZGK' in */
01322 /*           columns 1-3 to test ZGGBAK. */
01323 
01324 /*  The remaining lines consist of specially constructed test cases. */
01325 
01326 /* ----------------------------------------------------------------------- */
01327 
01328 /*  GLM data file: */
01329 
01330 /*  line 1:  'GLM' in columns 1 to 3. */
01331 
01332 /*  line 2:  NN, INTEGER */
01333 /*           Number of values of M, P, and N. */
01334 
01335 /*  line 3:  MVAL, INTEGER array, dimension(NN) */
01336 /*           Values of M (row dimension). */
01337 
01338 /*  line 4:  PVAL, INTEGER array, dimension(NN) */
01339 /*           Values of P (row dimension). */
01340 
01341 /*  line 5:  NVAL, INTEGER array, dimension(NN) */
01342 /*           Values of N (column dimension), note M <= N <= M+P. */
01343 
01344 /*  line 6:  THRESH, REAL */
01345 /*           Threshold value for the test ratios.  Information will be */
01346 /*           printed about each test for which the test ratio is greater */
01347 /*           than or equal to the threshold. */
01348 
01349 /*  line 7:  TSTERR, LOGICAL */
01350 /*           Flag indicating whether or not to test the error exits for */
01351 /*           the LAPACK routines and driver routines. */
01352 
01353 /*  line 8:  NEWSD, INTEGER */
01354 /*           A code indicating how to set the random number seed. */
01355 /*           = 0:  Set the seed to a default value before each run */
01356 /*           = 1:  Initialize the seed to a default value only before the */
01357 /*                 first run */
01358 /*           = 2:  Like 1, but use the seed values on the next line */
01359 
01360 /*  If line 8 was 2: */
01361 
01362 /*  line 9:  INTEGER array, dimension (4) */
01363 /*           Four integer values for the random number seed. */
01364 
01365 /*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
01366 /*           The 3-character path name is 'GLM' for the generalized */
01367 /*           linear regression model routines. */
01368 
01369 /* ----------------------------------------------------------------------- */
01370 
01371 /*  GQR data file: */
01372 
01373 /*  line 1:  'GQR' in columns 1 to 3. */
01374 
01375 /*  line 2:  NN, INTEGER */
01376 /*           Number of values of M, P, and N. */
01377 
01378 /*  line 3:  MVAL, INTEGER array, dimension(NN) */
01379 /*           Values of M. */
01380 
01381 /*  line 4:  PVAL, INTEGER array, dimension(NN) */
01382 /*           Values of P. */
01383 
01384 /*  line 5:  NVAL, INTEGER array, dimension(NN) */
01385 /*           Values of N. */
01386 
01387 /*  line 6:  THRESH, REAL */
01388 /*           Threshold value for the test ratios.  Information will be */
01389 /*           printed about each test for which the test ratio is greater */
01390 /*           than or equal to the threshold. */
01391 
01392 /*  line 7:  TSTERR, LOGICAL */
01393 /*           Flag indicating whether or not to test the error exits for */
01394 /*           the LAPACK routines and driver routines. */
01395 
01396 /*  line 8:  NEWSD, INTEGER */
01397 /*           A code indicating how to set the random number seed. */
01398 /*           = 0:  Set the seed to a default value before each run */
01399 /*           = 1:  Initialize the seed to a default value only before the */
01400 /*                 first run */
01401 /*           = 2:  Like 1, but use the seed values on the next line */
01402 
01403 /*  If line 8 was 2: */
01404 
01405 /*  line 9:  INTEGER array, dimension (4) */
01406 /*           Four integer values for the random number seed. */
01407 
01408 /*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
01409 /*           The 3-character path name is 'GQR' for the generalized */
01410 /*           QR and RQ routines. */
01411 
01412 /* ----------------------------------------------------------------------- */
01413 
01414 /*  GSV data file: */
01415 
01416 /*  line 1:  'GSV' in columns 1 to 3. */
01417 
01418 /*  line 2:  NN, INTEGER */
01419 /*           Number of values of M, P, and N. */
01420 
01421 /*  line 3:  MVAL, INTEGER array, dimension(NN) */
01422 /*           Values of M (row dimension). */
01423 
01424 /*  line 4:  PVAL, INTEGER array, dimension(NN) */
01425 /*           Values of P (row dimension). */
01426 
01427 /*  line 5:  NVAL, INTEGER array, dimension(NN) */
01428 /*           Values of N (column dimension). */
01429 
01430 /*  line 6:  THRESH, REAL */
01431 /*           Threshold value for the test ratios.  Information will be */
01432 /*           printed about each test for which the test ratio is greater */
01433 /*           than or equal to the threshold. */
01434 
01435 /*  line 7:  TSTERR, LOGICAL */
01436 /*           Flag indicating whether or not to test the error exits for */
01437 /*           the LAPACK routines and driver routines. */
01438 
01439 /*  line 8:  NEWSD, INTEGER */
01440 /*           A code indicating how to set the random number seed. */
01441 /*           = 0:  Set the seed to a default value before each run */
01442 /*           = 1:  Initialize the seed to a default value only before the */
01443 /*                 first run */
01444 /*           = 2:  Like 1, but use the seed values on the next line */
01445 
01446 /*  If line 8 was 2: */
01447 
01448 /*  line 9:  INTEGER array, dimension (4) */
01449 /*           Four integer values for the random number seed. */
01450 
01451 /*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
01452 /*           The 3-character path name is 'GSV' for the generalized */
01453 /*           SVD routines. */
01454 
01455 /* ----------------------------------------------------------------------- */
01456 
01457 /*  LSE data file: */
01458 
01459 /*  line 1:  'LSE' in columns 1 to 3. */
01460 
01461 /*  line 2:  NN, INTEGER */
01462 /*           Number of values of M, P, and N. */
01463 
01464 /*  line 3:  MVAL, INTEGER array, dimension(NN) */
01465 /*           Values of M. */
01466 
01467 /*  line 4:  PVAL, INTEGER array, dimension(NN) */
01468 /*           Values of P. */
01469 
01470 /*  line 5:  NVAL, INTEGER array, dimension(NN) */
01471 /*           Values of N, note P <= N <= P+M. */
01472 
01473 /*  line 6:  THRESH, REAL */
01474 /*           Threshold value for the test ratios.  Information will be */
01475 /*           printed about each test for which the test ratio is greater */
01476 /*           than or equal to the threshold. */
01477 
01478 /*  line 7:  TSTERR, LOGICAL */
01479 /*           Flag indicating whether or not to test the error exits for */
01480 /*           the LAPACK routines and driver routines. */
01481 
01482 /*  line 8:  NEWSD, INTEGER */
01483 /*           A code indicating how to set the random number seed. */
01484 /*           = 0:  Set the seed to a default value before each run */
01485 /*           = 1:  Initialize the seed to a default value only before the */
01486 /*                 first run */
01487 /*           = 2:  Like 1, but use the seed values on the next line */
01488 
01489 /*  If line 8 was 2: */
01490 
01491 /*  line 9:  INTEGER array, dimension (4) */
01492 /*           Four integer values for the random number seed. */
01493 
01494 /*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
01495 /*           The 3-character path name is 'GSV' for the generalized */
01496 /*           SVD routines. */
01497 
01498 /* ----------------------------------------------------------------------- */
01499 
01500 /*  NMAX is currently set to 132 and must be at least 12 for some of the */
01501 /*  precomputed examples, and LWORK = NMAX*(5*NMAX+20) in the parameter */
01502 /*  statements below.  For SVD, we assume NRHS may be as big as N.  The */
01503 /*  parameter NEED is set to 14 to allow for 14 N-by-N matrices for ZGG. */
01504 
01505 /*  ===================================================================== */
01506 
01507 /*     .. Parameters .. */
01508 /*     .. */
01509 /*     .. Local Scalars .. */
01510 /*     .. */
01511 /*     .. Local Arrays .. */
01512 /*     .. */
01513 /*     .. External Functions .. */
01514 /*     .. */
01515 /*     .. External Subroutines .. */
01516 /*     .. */
01517 /*     .. Intrinsic Functions .. */
01518 /*     .. */
01519 /*     .. Scalars in Common .. */
01520 /*     .. */
01521 /*     .. Arrays in Common .. */
01522 /*     .. */
01523 /*     .. Common blocks .. */
01524 /*     .. */
01525 /*     .. Data statements .. */
01526 /*     .. */
01527 /*     .. Executable Statements .. */
01528 
01529     s1 = dsecnd_();
01530     fatal = FALSE_;
01531     infoc_1.nunit = 6;
01532 
01533 /*     Return to here to read multiple sets of data */
01534 
01535 L10:
01536 
01537 /*     Read the first line and set the 3-character test path */
01538 
01539     ci__1.cierr = 0;
01540     ci__1.ciend = 1;
01541     ci__1.ciunit = 5;
01542     ci__1.cifmt = "(A80)";
01543     i__1 = s_rsfe(&ci__1);
01544     if (i__1 != 0) {
01545         goto L380;
01546     }
01547     i__1 = do_fio(&c__1, line, (ftnlen)80);
01548     if (i__1 != 0) {
01549         goto L380;
01550     }
01551     i__1 = e_rsfe();
01552     if (i__1 != 0) {
01553         goto L380;
01554     }
01555     s_copy(path, line, (ftnlen)3, (ftnlen)3);
01556     nep = lsamen_(&c__3, path, "NEP") || lsamen_(&c__3, 
01557             path, "ZHS");
01558     sep = lsamen_(&c__3, path, "SEP") || lsamen_(&c__3, 
01559             path, "ZST") || lsamen_(&c__3, path, "ZSG");
01560     svd = lsamen_(&c__3, path, "SVD") || lsamen_(&c__3, 
01561             path, "ZBD");
01562     zev = lsamen_(&c__3, path, "ZEV");
01563     zes = lsamen_(&c__3, path, "ZES");
01564     zvx = lsamen_(&c__3, path, "ZVX");
01565     zsx = lsamen_(&c__3, path, "ZSX");
01566     zgg = lsamen_(&c__3, path, "ZGG");
01567     zgs = lsamen_(&c__3, path, "ZGS");
01568     zgx = lsamen_(&c__3, path, "ZGX");
01569     zgv = lsamen_(&c__3, path, "ZGV");
01570     zxv = lsamen_(&c__3, path, "ZXV");
01571     zhb = lsamen_(&c__3, path, "ZHB");
01572     zbb = lsamen_(&c__3, path, "ZBB");
01573     glm = lsamen_(&c__3, path, "GLM");
01574     gqr = lsamen_(&c__3, path, "GQR") || lsamen_(&c__3, 
01575             path, "GRQ");
01576     gsv = lsamen_(&c__3, path, "GSV");
01577     lse = lsamen_(&c__3, path, "LSE");
01578     zbl = lsamen_(&c__3, path, "ZBL");
01579     zbk = lsamen_(&c__3, path, "ZBK");
01580     zgl = lsamen_(&c__3, path, "ZGL");
01581     zgk = lsamen_(&c__3, path, "ZGK");
01582 
01583 /*     Report values of parameters. */
01584 
01585     if (s_cmp(path, "   ", (ftnlen)3, (ftnlen)3) == 0) {
01586         goto L10;
01587     } else if (nep) {
01588         s_wsfe(&io___29);
01589         e_wsfe();
01590     } else if (sep) {
01591         s_wsfe(&io___30);
01592         e_wsfe();
01593     } else if (svd) {
01594         s_wsfe(&io___31);
01595         e_wsfe();
01596     } else if (zev) {
01597         s_wsfe(&io___32);
01598         e_wsfe();
01599     } else if (zes) {
01600         s_wsfe(&io___33);
01601         e_wsfe();
01602     } else if (zvx) {
01603         s_wsfe(&io___34);
01604         e_wsfe();
01605     } else if (zsx) {
01606         s_wsfe(&io___35);
01607         e_wsfe();
01608     } else if (zgg) {
01609         s_wsfe(&io___36);
01610         e_wsfe();
01611     } else if (zgs) {
01612         s_wsfe(&io___37);
01613         e_wsfe();
01614     } else if (zgx) {
01615         s_wsfe(&io___38);
01616         e_wsfe();
01617     } else if (zgv) {
01618         s_wsfe(&io___39);
01619         e_wsfe();
01620     } else if (zxv) {
01621         s_wsfe(&io___40);
01622         e_wsfe();
01623     } else if (zhb) {
01624         s_wsfe(&io___41);
01625         e_wsfe();
01626     } else if (zbb) {
01627         s_wsfe(&io___42);
01628         e_wsfe();
01629     } else if (glm) {
01630         s_wsfe(&io___43);
01631         e_wsfe();
01632     } else if (gqr) {
01633         s_wsfe(&io___44);
01634         e_wsfe();
01635     } else if (gsv) {
01636         s_wsfe(&io___45);
01637         e_wsfe();
01638     } else if (lse) {
01639         s_wsfe(&io___46);
01640         e_wsfe();
01641     } else if (zbl) {
01642 
01643 /*        ZGEBAL:  Balancing */
01644 
01645         zchkbl_(&c__5, &c__6);
01646         goto L380;
01647     } else if (zbk) {
01648 
01649 /*        ZGEBAK:  Back transformation */
01650 
01651         zchkbk_(&c__5, &c__6);
01652         goto L380;
01653     } else if (zgl) {
01654 
01655 /*        ZGGBAL:  Balancing */
01656 
01657         zchkgl_(&c__5, &c__6);
01658         goto L380;
01659     } else if (zgk) {
01660 
01661 /*        ZGGBAK:  Back transformation */
01662 
01663         zchkgk_(&c__5, &c__6);
01664         goto L380;
01665     } else if (lsamen_(&c__3, path, "ZEC")) {
01666 
01667 /*        ZEC:  Eigencondition estimation */
01668 
01669         s_rsle(&io___47);
01670         do_lio(&c__5, &c__1, (char *)&thresh, (ftnlen)sizeof(doublereal));
01671         e_rsle();
01672         xlaenv_(&c__1, &c__1);
01673         tsterr = TRUE_;
01674         zchkec_(&thresh, &tsterr, &c__5, &c__6);
01675         goto L380;
01676     } else {
01677         s_wsfe(&io___50);
01678         do_fio(&c__1, path, (ftnlen)3);
01679         e_wsfe();
01680         goto L380;
01681     }
01682     ilaver_(&vers_major__, &vers_minor__, &vers_patch__);
01683     s_wsfe(&io___54);
01684     do_fio(&c__1, (char *)&vers_major__, (ftnlen)sizeof(integer));
01685     do_fio(&c__1, (char *)&vers_minor__, (ftnlen)sizeof(integer));
01686     do_fio(&c__1, (char *)&vers_patch__, (ftnlen)sizeof(integer));
01687     e_wsfe();
01688     s_wsfe(&io___55);
01689     e_wsfe();
01690 
01691 /*     Read the number of values of M, P, and N. */
01692 
01693     s_rsle(&io___56);
01694     do_lio(&c__3, &c__1, (char *)&nn, (ftnlen)sizeof(integer));
01695     e_rsle();
01696     if (nn < 0) {
01697         s_wsfe(&io___58);
01698         do_fio(&c__1, "   NN ", (ftnlen)6);
01699         do_fio(&c__1, (char *)&nn, (ftnlen)sizeof(integer));
01700         do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01701         e_wsfe();
01702         nn = 0;
01703         fatal = TRUE_;
01704     } else if (nn > 20) {
01705         s_wsfe(&io___59);
01706         do_fio(&c__1, "   NN ", (ftnlen)6);
01707         do_fio(&c__1, (char *)&nn, (ftnlen)sizeof(integer));
01708         do_fio(&c__1, (char *)&c__20, (ftnlen)sizeof(integer));
01709         e_wsfe();
01710         nn = 0;
01711         fatal = TRUE_;
01712     }
01713 
01714 /*     Read the values of M */
01715 
01716     if (! (zgx || zxv)) {
01717         s_rsle(&io___60);
01718         i__1 = nn;
01719         for (i__ = 1; i__ <= i__1; ++i__) {
01720             do_lio(&c__3, &c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(
01721                     integer));
01722         }
01723         e_rsle();
01724         if (svd) {
01725             s_copy(vname, "    M ", (ftnlen)32, (ftnlen)6);
01726         } else {
01727             s_copy(vname, "    N ", (ftnlen)32, (ftnlen)6);
01728         }
01729         i__1 = nn;
01730         for (i__ = 1; i__ <= i__1; ++i__) {
01731             if (mval[i__ - 1] < 0) {
01732                 s_wsfe(&io___64);
01733                 do_fio(&c__1, vname, (ftnlen)32);
01734                 do_fio(&c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(integer))
01735                         ;
01736                 do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
01737                 e_wsfe();
01738                 fatal = TRUE_;
01739             } else if (mval[i__ - 1] > 132) {
01740                 s_wsfe(&io___65);
01741                 do_fio(&c__1, vname, (ftnlen)32);
01742                 do_fio(&c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(integer))
01743                         ;
01744                 do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
01745                 e_wsfe();
01746                 fatal = TRUE_;
01747             }
01748 /* L20: */
01749         }
01750         s_wsfe(&io___66);
01751         do_fio(&c__1, "M:    ", (ftnlen)6);
01752         i__1 = nn;
01753         for (i__ = 1; i__ <= i__1; ++i__) {
01754             do_fio(&c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(integer));
01755         }
01756         e_wsfe();
01757     }
01758 
01759 /*     Read the values of P */
01760 
01761     if (glm || gqr || gsv || lse) {
01762         s_rsle(&io___67);
01763         i__1 = nn;
01764         for (i__ = 1; i__ <= i__1; ++i__) {
01765             do_lio(&c__3, &c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(
01766                     integer));
01767         }
01768         e_rsle();
01769         i__1 = nn;
01770         for (i__ = 1; i__ <= i__1; ++i__) {
01771             if (pval[i__ - 1] < 0) {
01772                 s_wsfe(&io___69);
01773                 do_fio(&c__1, " P  ", (ftnlen)4);
01774                 do_fio(&c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(integer))
01775                         ;
01776                 do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
01777                 e_wsfe();
01778                 fatal = TRUE_;
01779             } else if (pval[i__ - 1] > 132) {
01780                 s_wsfe(&io___70);
01781                 do_fio(&c__1, " P  ", (ftnlen)4);
01782                 do_fio(&c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(integer))
01783                         ;
01784                 do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
01785                 e_wsfe();
01786                 fatal = TRUE_;
01787             }
01788 /* L30: */
01789         }
01790         s_wsfe(&io___71);
01791         do_fio(&c__1, "P:    ", (ftnlen)6);
01792         i__1 = nn;
01793         for (i__ = 1; i__ <= i__1; ++i__) {
01794             do_fio(&c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(integer));
01795         }
01796         e_wsfe();
01797     }
01798 
01799 /*     Read the values of N */
01800 
01801     if (svd || zbb || glm || gqr || gsv || lse) {
01802         s_rsle(&io___72);
01803         i__1 = nn;
01804         for (i__ = 1; i__ <= i__1; ++i__) {
01805             do_lio(&c__3, &c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(
01806                     integer));
01807         }
01808         e_rsle();
01809         i__1 = nn;
01810         for (i__ = 1; i__ <= i__1; ++i__) {
01811             if (nval[i__ - 1] < 0) {
01812                 s_wsfe(&io___74);
01813                 do_fio(&c__1, "    N ", (ftnlen)6);
01814                 do_fio(&c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(integer))
01815                         ;
01816                 do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
01817                 e_wsfe();
01818                 fatal = TRUE_;
01819             } else if (nval[i__ - 1] > 132) {
01820                 s_wsfe(&io___75);
01821                 do_fio(&c__1, "    N ", (ftnlen)6);
01822                 do_fio(&c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(integer))
01823                         ;
01824                 do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
01825                 e_wsfe();
01826                 fatal = TRUE_;
01827             }
01828 /* L40: */
01829         }
01830     } else {
01831         i__1 = nn;
01832         for (i__ = 1; i__ <= i__1; ++i__) {
01833             nval[i__ - 1] = mval[i__ - 1];
01834 /* L50: */
01835         }
01836     }
01837     if (! (zgx || zxv)) {
01838         s_wsfe(&io___76);
01839         do_fio(&c__1, "N:    ", (ftnlen)6);
01840         i__1 = nn;
01841         for (i__ = 1; i__ <= i__1; ++i__) {
01842             do_fio(&c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(integer));
01843         }
01844         e_wsfe();
01845     } else {
01846         s_wsfe(&io___77);
01847         do_fio(&c__1, "N:    ", (ftnlen)6);
01848         do_fio(&c__1, (char *)&nn, (ftnlen)sizeof(integer));
01849         e_wsfe();
01850     }
01851 
01852 /*     Read the number of values of K, followed by the values of K */
01853 
01854     if (zhb || zbb) {
01855         s_rsle(&io___78);
01856         do_lio(&c__3, &c__1, (char *)&nk, (ftnlen)sizeof(integer));
01857         e_rsle();
01858         s_rsle(&io___80);
01859         i__1 = nk;
01860         for (i__ = 1; i__ <= i__1; ++i__) {
01861             do_lio(&c__3, &c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(
01862                     integer));
01863         }
01864         e_rsle();
01865         i__1 = nk;
01866         for (i__ = 1; i__ <= i__1; ++i__) {
01867             if (kval[i__ - 1] < 0) {
01868                 s_wsfe(&io___82);
01869                 do_fio(&c__1, "    K ", (ftnlen)6);
01870                 do_fio(&c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(integer))
01871                         ;
01872                 do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
01873                 e_wsfe();
01874                 fatal = TRUE_;
01875             } else if (kval[i__ - 1] > 132) {
01876                 s_wsfe(&io___83);
01877                 do_fio(&c__1, "    K ", (ftnlen)6);
01878                 do_fio(&c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(integer))
01879                         ;
01880                 do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
01881                 e_wsfe();
01882                 fatal = TRUE_;
01883             }
01884 /* L60: */
01885         }
01886         s_wsfe(&io___84);
01887         do_fio(&c__1, "K:    ", (ftnlen)6);
01888         i__1 = nk;
01889         for (i__ = 1; i__ <= i__1; ++i__) {
01890             do_fio(&c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(integer));
01891         }
01892         e_wsfe();
01893     }
01894 
01895     if (zev || zes || zvx || zsx) {
01896 
01897 /*        For the nonsymmetric QR driver routines, only one set of */
01898 /*        parameters is allowed. */
01899 
01900         s_rsle(&io___85);
01901         do_lio(&c__3, &c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
01902         do_lio(&c__3, &c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
01903         do_lio(&c__3, &c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
01904         do_lio(&c__3, &c__1, (char *)&inmin[0], (ftnlen)sizeof(integer));
01905         do_lio(&c__3, &c__1, (char *)&inwin[0], (ftnlen)sizeof(integer));
01906         do_lio(&c__3, &c__1, (char *)&inibl[0], (ftnlen)sizeof(integer));
01907         do_lio(&c__3, &c__1, (char *)&ishfts[0], (ftnlen)sizeof(integer));
01908         do_lio(&c__3, &c__1, (char *)&iacc22[0], (ftnlen)sizeof(integer));
01909         e_rsle();
01910         if (nbval[0] < 1) {
01911             s_wsfe(&io___94);
01912             do_fio(&c__1, "   NB ", (ftnlen)6);
01913             do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
01914             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01915             e_wsfe();
01916             fatal = TRUE_;
01917         } else if (nbmin[0] < 1) {
01918             s_wsfe(&io___95);
01919             do_fio(&c__1, "NBMIN ", (ftnlen)6);
01920             do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
01921             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01922             e_wsfe();
01923             fatal = TRUE_;
01924         } else if (nxval[0] < 1) {
01925             s_wsfe(&io___96);
01926             do_fio(&c__1, "   NX ", (ftnlen)6);
01927             do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
01928             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01929             e_wsfe();
01930             fatal = TRUE_;
01931         } else if (inmin[0] < 1) {
01932             s_wsfe(&io___97);
01933             do_fio(&c__1, "   INMIN ", (ftnlen)9);
01934             do_fio(&c__1, (char *)&inmin[0], (ftnlen)sizeof(integer));
01935             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01936             e_wsfe();
01937             fatal = TRUE_;
01938         } else if (inwin[0] < 1) {
01939             s_wsfe(&io___98);
01940             do_fio(&c__1, "   INWIN ", (ftnlen)9);
01941             do_fio(&c__1, (char *)&inwin[0], (ftnlen)sizeof(integer));
01942             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01943             e_wsfe();
01944             fatal = TRUE_;
01945         } else if (inibl[0] < 1) {
01946             s_wsfe(&io___99);
01947             do_fio(&c__1, "   INIBL ", (ftnlen)9);
01948             do_fio(&c__1, (char *)&inibl[0], (ftnlen)sizeof(integer));
01949             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01950             e_wsfe();
01951             fatal = TRUE_;
01952         } else if (ishfts[0] < 1) {
01953             s_wsfe(&io___100);
01954             do_fio(&c__1, "   ISHFTS ", (ftnlen)10);
01955             do_fio(&c__1, (char *)&ishfts[0], (ftnlen)sizeof(integer));
01956             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
01957             e_wsfe();
01958             fatal = TRUE_;
01959         } else if (iacc22[0] < 0) {
01960             s_wsfe(&io___101);
01961             do_fio(&c__1, "   IACC22 ", (ftnlen)10);
01962             do_fio(&c__1, (char *)&iacc22[0], (ftnlen)sizeof(integer));
01963             do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
01964             e_wsfe();
01965             fatal = TRUE_;
01966         }
01967         xlaenv_(&c__1, nbval);
01968         xlaenv_(&c__2, nbmin);
01969         xlaenv_(&c__3, nxval);
01970         i__1 = max(11,inmin[0]);
01971         xlaenv_(&c__12, &i__1);
01972         xlaenv_(&c__13, inwin);
01973         xlaenv_(&c__14, inibl);
01974         xlaenv_(&c__15, ishfts);
01975         xlaenv_(&c__16, iacc22);
01976         s_wsfe(&io___102);
01977         do_fio(&c__1, "NB:   ", (ftnlen)6);
01978         do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
01979         e_wsfe();
01980         s_wsfe(&io___103);
01981         do_fio(&c__1, "NBMIN:", (ftnlen)6);
01982         do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
01983         e_wsfe();
01984         s_wsfe(&io___104);
01985         do_fio(&c__1, "NX:   ", (ftnlen)6);
01986         do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
01987         e_wsfe();
01988         s_wsfe(&io___105);
01989         do_fio(&c__1, "INMIN:   ", (ftnlen)9);
01990         do_fio(&c__1, (char *)&inmin[0], (ftnlen)sizeof(integer));
01991         e_wsfe();
01992         s_wsfe(&io___106);
01993         do_fio(&c__1, "INWIN: ", (ftnlen)7);
01994         do_fio(&c__1, (char *)&inwin[0], (ftnlen)sizeof(integer));
01995         e_wsfe();
01996         s_wsfe(&io___107);
01997         do_fio(&c__1, "INIBL: ", (ftnlen)7);
01998         do_fio(&c__1, (char *)&inibl[0], (ftnlen)sizeof(integer));
01999         e_wsfe();
02000         s_wsfe(&io___108);
02001         do_fio(&c__1, "ISHFTS: ", (ftnlen)8);
02002         do_fio(&c__1, (char *)&ishfts[0], (ftnlen)sizeof(integer));
02003         e_wsfe();
02004         s_wsfe(&io___109);
02005         do_fio(&c__1, "IACC22: ", (ftnlen)8);
02006         do_fio(&c__1, (char *)&iacc22[0], (ftnlen)sizeof(integer));
02007         e_wsfe();
02008 
02009     } else if (zgs || zgx || zgv || zxv) {
02010 
02011 /*        For the nonsymmetric generalized driver routines, only one set of */
02012 /*        parameters is allowed. */
02013 
02014         s_rsle(&io___110);
02015         do_lio(&c__3, &c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
02016         do_lio(&c__3, &c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
02017         do_lio(&c__3, &c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
02018         do_lio(&c__3, &c__1, (char *)&nsval[0], (ftnlen)sizeof(integer));
02019         do_lio(&c__3, &c__1, (char *)&mxbval[0], (ftnlen)sizeof(integer));
02020         e_rsle();
02021         if (nbval[0] < 1) {
02022             s_wsfe(&io___113);
02023             do_fio(&c__1, "   NB ", (ftnlen)6);
02024             do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
02025             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
02026             e_wsfe();
02027             fatal = TRUE_;
02028         } else if (nbmin[0] < 1) {
02029             s_wsfe(&io___114);
02030             do_fio(&c__1, "NBMIN ", (ftnlen)6);
02031             do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
02032             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
02033             e_wsfe();
02034             fatal = TRUE_;
02035         } else if (nxval[0] < 1) {
02036             s_wsfe(&io___115);
02037             do_fio(&c__1, "   NX ", (ftnlen)6);
02038             do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
02039             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
02040             e_wsfe();
02041             fatal = TRUE_;
02042         } else if (nsval[0] < 2) {
02043             s_wsfe(&io___116);
02044             do_fio(&c__1, "   NS ", (ftnlen)6);
02045             do_fio(&c__1, (char *)&nsval[0], (ftnlen)sizeof(integer));
02046             do_fio(&c__1, (char *)&c__2, (ftnlen)sizeof(integer));
02047             e_wsfe();
02048             fatal = TRUE_;
02049         } else if (mxbval[0] < 1) {
02050             s_wsfe(&io___117);
02051             do_fio(&c__1, " MAXB ", (ftnlen)6);
02052             do_fio(&c__1, (char *)&mxbval[0], (ftnlen)sizeof(integer));
02053             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
02054             e_wsfe();
02055             fatal = TRUE_;
02056         }
02057         xlaenv_(&c__1, nbval);
02058         xlaenv_(&c__2, nbmin);
02059         xlaenv_(&c__3, nxval);
02060         xlaenv_(&c__4, nsval);
02061         xlaenv_(&c__8, mxbval);
02062         s_wsfe(&io___118);
02063         do_fio(&c__1, "NB:   ", (ftnlen)6);
02064         do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
02065         e_wsfe();
02066         s_wsfe(&io___119);
02067         do_fio(&c__1, "NBMIN:", (ftnlen)6);
02068         do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
02069         e_wsfe();
02070         s_wsfe(&io___120);
02071         do_fio(&c__1, "NX:   ", (ftnlen)6);
02072         do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
02073         e_wsfe();
02074         s_wsfe(&io___121);
02075         do_fio(&c__1, "NS:   ", (ftnlen)6);
02076         do_fio(&c__1, (char *)&nsval[0], (ftnlen)sizeof(integer));
02077         e_wsfe();
02078         s_wsfe(&io___122);
02079         do_fio(&c__1, "MAXB: ", (ftnlen)6);
02080         do_fio(&c__1, (char *)&mxbval[0], (ftnlen)sizeof(integer));
02081         e_wsfe();
02082     } else if (! zhb && ! glm && ! gqr && ! gsv && ! lse) {
02083 
02084 /*        For the other paths, the number of parameters can be varied */
02085 /*        from the input file.  Read the number of parameter values. */
02086 
02087         s_rsle(&io___123);
02088         do_lio(&c__3, &c__1, (char *)&nparms, (ftnlen)sizeof(integer));
02089         e_rsle();
02090         if (nparms < 1) {
02091             s_wsfe(&io___125);
02092             do_fio(&c__1, "NPARMS", (ftnlen)6);
02093             do_fio(&c__1, (char *)&nparms, (ftnlen)sizeof(integer));
02094             do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
02095             e_wsfe();
02096             nparms = 0;
02097             fatal = TRUE_;
02098         } else if (nparms > 20) {
02099             s_wsfe(&io___126);
02100             do_fio(&c__1, "NPARMS", (ftnlen)6);
02101             do_fio(&c__1, (char *)&nparms, (ftnlen)sizeof(integer));
02102             do_fio(&c__1, (char *)&c__20, (ftnlen)sizeof(integer));
02103             e_wsfe();
02104             nparms = 0;
02105             fatal = TRUE_;
02106         }
02107 
02108 /*        Read the values of NB */
02109 
02110         if (! zbb) {
02111             s_rsle(&io___127);
02112             i__1 = nparms;
02113             for (i__ = 1; i__ <= i__1; ++i__) {
02114                 do_lio(&c__3, &c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(
02115                         integer));
02116             }
02117             e_rsle();
02118             i__1 = nparms;
02119             for (i__ = 1; i__ <= i__1; ++i__) {
02120                 if (nbval[i__ - 1] < 0) {
02121                     s_wsfe(&io___128);
02122                     do_fio(&c__1, "   NB ", (ftnlen)6);
02123                     do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(
02124                             integer));
02125                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02126                     e_wsfe();
02127                     fatal = TRUE_;
02128                 } else if (nbval[i__ - 1] > 132) {
02129                     s_wsfe(&io___129);
02130                     do_fio(&c__1, "   NB ", (ftnlen)6);
02131                     do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(
02132                             integer));
02133                     do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
02134                     e_wsfe();
02135                     fatal = TRUE_;
02136                 }
02137 /* L70: */
02138             }
02139             s_wsfe(&io___130);
02140             do_fio(&c__1, "NB:   ", (ftnlen)6);
02141             i__1 = nparms;
02142             for (i__ = 1; i__ <= i__1; ++i__) {
02143                 do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer)
02144                         );
02145             }
02146             e_wsfe();
02147         }
02148 
02149 /*        Read the values of NBMIN */
02150 
02151         if (nep || sep || svd || zgg) {
02152             s_rsle(&io___131);
02153             i__1 = nparms;
02154             for (i__ = 1; i__ <= i__1; ++i__) {
02155                 do_lio(&c__3, &c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(
02156                         integer));
02157             }
02158             e_rsle();
02159             i__1 = nparms;
02160             for (i__ = 1; i__ <= i__1; ++i__) {
02161                 if (nbmin[i__ - 1] < 0) {
02162                     s_wsfe(&io___132);
02163                     do_fio(&c__1, "NBMIN ", (ftnlen)6);
02164                     do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(
02165                             integer));
02166                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02167                     e_wsfe();
02168                     fatal = TRUE_;
02169                 } else if (nbmin[i__ - 1] > 132) {
02170                     s_wsfe(&io___133);
02171                     do_fio(&c__1, "NBMIN ", (ftnlen)6);
02172                     do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(
02173                             integer));
02174                     do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
02175                     e_wsfe();
02176                     fatal = TRUE_;
02177                 }
02178 /* L80: */
02179             }
02180             s_wsfe(&io___134);
02181             do_fio(&c__1, "NBMIN:", (ftnlen)6);
02182             i__1 = nparms;
02183             for (i__ = 1; i__ <= i__1; ++i__) {
02184                 do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer)
02185                         );
02186             }
02187             e_wsfe();
02188         } else {
02189             i__1 = nparms;
02190             for (i__ = 1; i__ <= i__1; ++i__) {
02191                 nbmin[i__ - 1] = 1;
02192 /* L90: */
02193             }
02194         }
02195 
02196 /*        Read the values of NX */
02197 
02198         if (nep || sep || svd) {
02199             s_rsle(&io___135);
02200             i__1 = nparms;
02201             for (i__ = 1; i__ <= i__1; ++i__) {
02202                 do_lio(&c__3, &c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(
02203                         integer));
02204             }
02205             e_rsle();
02206             i__1 = nparms;
02207             for (i__ = 1; i__ <= i__1; ++i__) {
02208                 if (nxval[i__ - 1] < 0) {
02209                     s_wsfe(&io___136);
02210                     do_fio(&c__1, "   NX ", (ftnlen)6);
02211                     do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(
02212                             integer));
02213                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02214                     e_wsfe();
02215                     fatal = TRUE_;
02216                 } else if (nxval[i__ - 1] > 132) {
02217                     s_wsfe(&io___137);
02218                     do_fio(&c__1, "   NX ", (ftnlen)6);
02219                     do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(
02220                             integer));
02221                     do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
02222                     e_wsfe();
02223                     fatal = TRUE_;
02224                 }
02225 /* L100: */
02226             }
02227             s_wsfe(&io___138);
02228             do_fio(&c__1, "NX:   ", (ftnlen)6);
02229             i__1 = nparms;
02230             for (i__ = 1; i__ <= i__1; ++i__) {
02231                 do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer)
02232                         );
02233             }
02234             e_wsfe();
02235         } else {
02236             i__1 = nparms;
02237             for (i__ = 1; i__ <= i__1; ++i__) {
02238                 nxval[i__ - 1] = 1;
02239 /* L110: */
02240             }
02241         }
02242 
02243 /*        Read the values of NSHIFT (if ZGG) or NRHS (if SVD */
02244 /*        or ZBB). */
02245 
02246         if (svd || zbb || zgg) {
02247             s_rsle(&io___139);
02248             i__1 = nparms;
02249             for (i__ = 1; i__ <= i__1; ++i__) {
02250                 do_lio(&c__3, &c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(
02251                         integer));
02252             }
02253             e_rsle();
02254             i__1 = nparms;
02255             for (i__ = 1; i__ <= i__1; ++i__) {
02256                 if (nsval[i__ - 1] < 0) {
02257                     s_wsfe(&io___140);
02258                     do_fio(&c__1, "   NS ", (ftnlen)6);
02259                     do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(
02260                             integer));
02261                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02262                     e_wsfe();
02263                     fatal = TRUE_;
02264                 } else if (nsval[i__ - 1] > 132) {
02265                     s_wsfe(&io___141);
02266                     do_fio(&c__1, "   NS ", (ftnlen)6);
02267                     do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(
02268                             integer));
02269                     do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
02270                     e_wsfe();
02271                     fatal = TRUE_;
02272                 }
02273 /* L120: */
02274             }
02275             s_wsfe(&io___142);
02276             do_fio(&c__1, "NS:   ", (ftnlen)6);
02277             i__1 = nparms;
02278             for (i__ = 1; i__ <= i__1; ++i__) {
02279                 do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(integer)
02280                         );
02281             }
02282             e_wsfe();
02283         } else {
02284             i__1 = nparms;
02285             for (i__ = 1; i__ <= i__1; ++i__) {
02286                 nsval[i__ - 1] = 1;
02287 /* L130: */
02288             }
02289         }
02290 
02291 /*        Read the values for MAXB. */
02292 
02293         if (zgg) {
02294             s_rsle(&io___143);
02295             i__1 = nparms;
02296             for (i__ = 1; i__ <= i__1; ++i__) {
02297                 do_lio(&c__3, &c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
02298                         integer));
02299             }
02300             e_rsle();
02301             i__1 = nparms;
02302             for (i__ = 1; i__ <= i__1; ++i__) {
02303                 if (mxbval[i__ - 1] < 0) {
02304                     s_wsfe(&io___144);
02305                     do_fio(&c__1, " MAXB ", (ftnlen)6);
02306                     do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
02307                             integer));
02308                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02309                     e_wsfe();
02310                     fatal = TRUE_;
02311                 } else if (mxbval[i__ - 1] > 132) {
02312                     s_wsfe(&io___145);
02313                     do_fio(&c__1, " MAXB ", (ftnlen)6);
02314                     do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
02315                             integer));
02316                     do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
02317                     e_wsfe();
02318                     fatal = TRUE_;
02319                 }
02320 /* L140: */
02321             }
02322             s_wsfe(&io___146);
02323             do_fio(&c__1, "MAXB: ", (ftnlen)6);
02324             i__1 = nparms;
02325             for (i__ = 1; i__ <= i__1; ++i__) {
02326                 do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
02327                         integer));
02328             }
02329             e_wsfe();
02330         } else {
02331             i__1 = nparms;
02332             for (i__ = 1; i__ <= i__1; ++i__) {
02333                 mxbval[i__ - 1] = 1;
02334 /* L150: */
02335             }
02336         }
02337 
02338 /*        Read the values for INMIN. */
02339 
02340         if (nep) {
02341             s_rsle(&io___147);
02342             i__1 = nparms;
02343             for (i__ = 1; i__ <= i__1; ++i__) {
02344                 do_lio(&c__3, &c__1, (char *)&inmin[i__ - 1], (ftnlen)sizeof(
02345                         integer));
02346             }
02347             e_rsle();
02348             i__1 = nparms;
02349             for (i__ = 1; i__ <= i__1; ++i__) {
02350                 if (inmin[i__ - 1] < 0) {
02351                     s_wsfe(&io___148);
02352                     do_fio(&c__1, " INMIN ", (ftnlen)7);
02353                     do_fio(&c__1, (char *)&inmin[i__ - 1], (ftnlen)sizeof(
02354                             integer));
02355                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02356                     e_wsfe();
02357                     fatal = TRUE_;
02358                 }
02359 /* L540: */
02360             }
02361             s_wsfe(&io___149);
02362             do_fio(&c__1, "INMIN: ", (ftnlen)7);
02363             i__1 = nparms;
02364             for (i__ = 1; i__ <= i__1; ++i__) {
02365                 do_fio(&c__1, (char *)&inmin[i__ - 1], (ftnlen)sizeof(integer)
02366                         );
02367             }
02368             e_wsfe();
02369         } else {
02370             i__1 = nparms;
02371             for (i__ = 1; i__ <= i__1; ++i__) {
02372                 inmin[i__ - 1] = 1;
02373 /* L550: */
02374             }
02375         }
02376 
02377 /*        Read the values for INWIN. */
02378 
02379         if (nep) {
02380             s_rsle(&io___150);
02381             i__1 = nparms;
02382             for (i__ = 1; i__ <= i__1; ++i__) {
02383                 do_lio(&c__3, &c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(
02384                         integer));
02385             }
02386             e_rsle();
02387             i__1 = nparms;
02388             for (i__ = 1; i__ <= i__1; ++i__) {
02389                 if (inwin[i__ - 1] < 0) {
02390                     s_wsfe(&io___151);
02391                     do_fio(&c__1, " INWIN ", (ftnlen)7);
02392                     do_fio(&c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(
02393                             integer));
02394                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02395                     e_wsfe();
02396                     fatal = TRUE_;
02397                 }
02398 /* L560: */
02399             }
02400             s_wsfe(&io___152);
02401             do_fio(&c__1, "INWIN: ", (ftnlen)7);
02402             i__1 = nparms;
02403             for (i__ = 1; i__ <= i__1; ++i__) {
02404                 do_fio(&c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(integer)
02405                         );
02406             }
02407             e_wsfe();
02408         } else {
02409             i__1 = nparms;
02410             for (i__ = 1; i__ <= i__1; ++i__) {
02411                 inwin[i__ - 1] = 1;
02412 /* L570: */
02413             }
02414         }
02415 
02416 /*        Read the values for INIBL. */
02417 
02418         if (nep) {
02419             s_rsle(&io___153);
02420             i__1 = nparms;
02421             for (i__ = 1; i__ <= i__1; ++i__) {
02422                 do_lio(&c__3, &c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(
02423                         integer));
02424             }
02425             e_rsle();
02426             i__1 = nparms;
02427             for (i__ = 1; i__ <= i__1; ++i__) {
02428                 if (inibl[i__ - 1] < 0) {
02429                     s_wsfe(&io___154);
02430                     do_fio(&c__1, " INIBL ", (ftnlen)7);
02431                     do_fio(&c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(
02432                             integer));
02433                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02434                     e_wsfe();
02435                     fatal = TRUE_;
02436                 }
02437 /* L580: */
02438             }
02439             s_wsfe(&io___155);
02440             do_fio(&c__1, "INIBL: ", (ftnlen)7);
02441             i__1 = nparms;
02442             for (i__ = 1; i__ <= i__1; ++i__) {
02443                 do_fio(&c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(integer)
02444                         );
02445             }
02446             e_wsfe();
02447         } else {
02448             i__1 = nparms;
02449             for (i__ = 1; i__ <= i__1; ++i__) {
02450                 inibl[i__ - 1] = 1;
02451 /* L590: */
02452             }
02453         }
02454 
02455 /*        Read the values for ISHFTS. */
02456 
02457         if (nep) {
02458             s_rsle(&io___156);
02459             i__1 = nparms;
02460             for (i__ = 1; i__ <= i__1; ++i__) {
02461                 do_lio(&c__3, &c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(
02462                         integer));
02463             }
02464             e_rsle();
02465             i__1 = nparms;
02466             for (i__ = 1; i__ <= i__1; ++i__) {
02467                 if (ishfts[i__ - 1] < 0) {
02468                     s_wsfe(&io___157);
02469                     do_fio(&c__1, " ISHFTS ", (ftnlen)8);
02470                     do_fio(&c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(
02471                             integer));
02472                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02473                     e_wsfe();
02474                     fatal = TRUE_;
02475                 }
02476 /* L600: */
02477             }
02478             s_wsfe(&io___158);
02479             do_fio(&c__1, "ISHFTS: ", (ftnlen)8);
02480             i__1 = nparms;
02481             for (i__ = 1; i__ <= i__1; ++i__) {
02482                 do_fio(&c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(
02483                         integer));
02484             }
02485             e_wsfe();
02486         } else {
02487             i__1 = nparms;
02488             for (i__ = 1; i__ <= i__1; ++i__) {
02489                 ishfts[i__ - 1] = 1;
02490 /* L610: */
02491             }
02492         }
02493 
02494 /*        Read the values for IACC22. */
02495 
02496         if (nep) {
02497             s_rsle(&io___159);
02498             i__1 = nparms;
02499             for (i__ = 1; i__ <= i__1; ++i__) {
02500                 do_lio(&c__3, &c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(
02501                         integer));
02502             }
02503             e_rsle();
02504             i__1 = nparms;
02505             for (i__ = 1; i__ <= i__1; ++i__) {
02506                 if (iacc22[i__ - 1] < 0) {
02507                     s_wsfe(&io___160);
02508                     do_fio(&c__1, " IACC22 ", (ftnlen)8);
02509                     do_fio(&c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(
02510                             integer));
02511                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02512                     e_wsfe();
02513                     fatal = TRUE_;
02514                 }
02515 /* L620: */
02516             }
02517             s_wsfe(&io___161);
02518             do_fio(&c__1, "IACC22: ", (ftnlen)8);
02519             i__1 = nparms;
02520             for (i__ = 1; i__ <= i__1; ++i__) {
02521                 do_fio(&c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(
02522                         integer));
02523             }
02524             e_wsfe();
02525         } else {
02526             i__1 = nparms;
02527             for (i__ = 1; i__ <= i__1; ++i__) {
02528                 iacc22[i__ - 1] = 1;
02529 /* L630: */
02530             }
02531         }
02532 
02533 /*        Read the values for NBCOL. */
02534 
02535         if (zgg) {
02536             s_rsle(&io___162);
02537             i__1 = nparms;
02538             for (i__ = 1; i__ <= i__1; ++i__) {
02539                 do_lio(&c__3, &c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(
02540                         integer));
02541             }
02542             e_rsle();
02543             i__1 = nparms;
02544             for (i__ = 1; i__ <= i__1; ++i__) {
02545                 if (nbcol[i__ - 1] < 0) {
02546                     s_wsfe(&io___164);
02547                     do_fio(&c__1, "NBCOL ", (ftnlen)6);
02548                     do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(
02549                             integer));
02550                     do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
02551                     e_wsfe();
02552                     fatal = TRUE_;
02553                 } else if (nbcol[i__ - 1] > 132) {
02554                     s_wsfe(&io___165);
02555                     do_fio(&c__1, "NBCOL ", (ftnlen)6);
02556                     do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(
02557                             integer));
02558                     do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
02559                     e_wsfe();
02560                     fatal = TRUE_;
02561                 }
02562 /* L160: */
02563             }
02564             s_wsfe(&io___166);
02565             do_fio(&c__1, "NBCOL:", (ftnlen)6);
02566             i__1 = nparms;
02567             for (i__ = 1; i__ <= i__1; ++i__) {
02568                 do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(integer)
02569                         );
02570             }
02571             e_wsfe();
02572         } else {
02573             i__1 = nparms;
02574             for (i__ = 1; i__ <= i__1; ++i__) {
02575                 nbcol[i__ - 1] = 1;
02576 /* L170: */
02577             }
02578         }
02579     }
02580 
02581 /*     Calculate and print the machine dependent constants. */
02582 
02583     s_wsle(&io___167);
02584     e_wsle();
02585     eps = dlamch_("Underflow threshold");
02586     s_wsfe(&io___169);
02587     do_fio(&c__1, "underflow", (ftnlen)9);
02588     do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(doublereal));
02589     e_wsfe();
02590     eps = dlamch_("Overflow threshold");
02591     s_wsfe(&io___170);
02592     do_fio(&c__1, "overflow ", (ftnlen)9);
02593     do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(doublereal));
02594     e_wsfe();
02595     eps = dlamch_("Epsilon");
02596     s_wsfe(&io___171);
02597     do_fio(&c__1, "precision", (ftnlen)9);
02598     do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(doublereal));
02599     e_wsfe();
02600 
02601 /*     Read the threshold value for the test ratios. */
02602 
02603     s_rsle(&io___172);
02604     do_lio(&c__5, &c__1, (char *)&thresh, (ftnlen)sizeof(doublereal));
02605     e_rsle();
02606     s_wsfe(&io___173);
02607     do_fio(&c__1, (char *)&thresh, (ftnlen)sizeof(doublereal));
02608     e_wsfe();
02609     if (sep || svd || zgg) {
02610 
02611 /*        Read the flag that indicates whether to test LAPACK routines. */
02612 
02613         s_rsle(&io___174);
02614         do_lio(&c__8, &c__1, (char *)&tstchk, (ftnlen)sizeof(logical));
02615         e_rsle();
02616 
02617 /*        Read the flag that indicates whether to test driver routines. */
02618 
02619         s_rsle(&io___176);
02620         do_lio(&c__8, &c__1, (char *)&tstdrv, (ftnlen)sizeof(logical));
02621         e_rsle();
02622     }
02623 
02624 /*     Read the flag that indicates whether to test the error exits. */
02625 
02626     s_rsle(&io___178);
02627     do_lio(&c__8, &c__1, (char *)&tsterr, (ftnlen)sizeof(logical));
02628     e_rsle();
02629 
02630 /*     Read the code describing how to set the random number seed. */
02631 
02632     s_rsle(&io___179);
02633     do_lio(&c__3, &c__1, (char *)&newsd, (ftnlen)sizeof(integer));
02634     e_rsle();
02635 
02636 /*     If NEWSD = 2, read another line with 4 integers for the seed. */
02637 
02638     if (newsd == 2) {
02639         s_rsle(&io___181);
02640         for (i__ = 1; i__ <= 4; ++i__) {
02641             do_lio(&c__3, &c__1, (char *)&ioldsd[i__ - 1], (ftnlen)sizeof(
02642                     integer));
02643         }
02644         e_rsle();
02645     }
02646 
02647     for (i__ = 1; i__ <= 4; ++i__) {
02648         iseed[i__ - 1] = ioldsd[i__ - 1];
02649 /* L180: */
02650     }
02651 
02652     if (fatal) {
02653         s_wsfe(&io___183);
02654         e_wsfe();
02655         s_stop("", (ftnlen)0);
02656     }
02657 
02658 /*     Read the input lines indicating the test path and its parameters. */
02659 /*     The first three characters indicate the test path, and the number */
02660 /*     of test matrix types must be the first nonblank item in columns */
02661 /*     4-80. */
02662 
02663 L190:
02664 
02665     if (! (zgx || zxv)) {
02666 
02667 L200:
02668         ci__1.cierr = 0;
02669         ci__1.ciend = 1;
02670         ci__1.ciunit = 5;
02671         ci__1.cifmt = "(A80)";
02672         i__1 = s_rsfe(&ci__1);
02673         if (i__1 != 0) {
02674             goto L380;
02675         }
02676         i__1 = do_fio(&c__1, line, (ftnlen)80);
02677         if (i__1 != 0) {
02678             goto L380;
02679         }
02680         i__1 = e_rsfe();
02681         if (i__1 != 0) {
02682             goto L380;
02683         }
02684         s_copy(c3, line, (ftnlen)3, (ftnlen)3);
02685         lenp = i_len(line, (ftnlen)80);
02686         i__ = 3;
02687         itmp = 0;
02688         i1 = 0;
02689 L210:
02690         ++i__;
02691         if (i__ > lenp) {
02692             if (i1 > 0) {
02693                 goto L240;
02694             } else {
02695                 ntypes = 30;
02696                 goto L240;
02697             }
02698         }
02699         if (*(unsigned char *)&line[i__ - 1] != ' ' && *(unsigned char *)&
02700                 line[i__ - 1] != ',') {
02701             i1 = i__;
02702             *(unsigned char *)c1 = *(unsigned char *)&line[i1 - 1];
02703 
02704 /*        Check that a valid integer was read */
02705 
02706             for (k = 1; k <= 10; ++k) {
02707                 if (*(unsigned char *)c1 == *(unsigned char *)&intstr[k - 1]) 
02708                         {
02709                     ic = k - 1;
02710                     goto L230;
02711                 }
02712 /* L220: */
02713             }
02714             s_wsfe(&io___192);
02715             do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
02716             do_fio(&c__1, line, (ftnlen)80);
02717             e_wsfe();
02718             goto L200;
02719 L230:
02720             itmp = itmp * 10 + ic;
02721             goto L210;
02722         } else if (i1 > 0) {
02723             goto L240;
02724         } else {
02725             goto L210;
02726         }
02727 L240:
02728         ntypes = itmp;
02729 
02730 /*     Skip the tests if NTYPES is <= 0. */
02731 
02732         if (! (zev || zes || zvx || zsx || zgv || zgs) && ntypes <= 0) {
02733             s_wsfe(&io___193);
02734             do_fio(&c__1, c3, (ftnlen)3);
02735             e_wsfe();
02736             goto L200;
02737         }
02738 
02739     } else {
02740         if (zgx) {
02741             s_copy(c3, "ZGX", (ftnlen)3, (ftnlen)3);
02742         }
02743         if (zxv) {
02744             s_copy(c3, "ZXV", (ftnlen)3, (ftnlen)3);
02745         }
02746     }
02747 
02748 /*     Reset the random number seed. */
02749 
02750     if (newsd == 0) {
02751         for (k = 1; k <= 4; ++k) {
02752             iseed[k - 1] = ioldsd[k - 1];
02753 /* L250: */
02754         }
02755     }
02756 
02757     if (lsamen_(&c__3, c3, "ZHS") || lsamen_(&c__3, c3, 
02758             "NEP")) {
02759 
02760 /*        ------------------------------------- */
02761 /*        NEP:  Nonsymmetric Eigenvalue Problem */
02762 /*        ------------------------------------- */
02763 /*        Vary the parameters */
02764 /*           NB    = block size */
02765 /*           NBMIN = minimum block size */
02766 /*           NX    = crossover point */
02767 /*           NS    = number of shifts */
02768 /*           MAXB  = minimum submatrix size */
02769 
02770         maxtyp = 21;
02771         ntypes = min(maxtyp,ntypes);
02772         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
02773         xlaenv_(&c__1, &c__1);
02774         if (tsterr) {
02775             zerrhs_("ZHSEQR", &c__6);
02776         }
02777         i__1 = nparms;
02778         for (i__ = 1; i__ <= i__1; ++i__) {
02779             xlaenv_(&c__1, &nbval[i__ - 1]);
02780             xlaenv_(&c__2, &nbmin[i__ - 1]);
02781             xlaenv_(&c__3, &nxval[i__ - 1]);
02782 /* Computing MAX */
02783             i__3 = 11, i__4 = inmin[i__ - 1];
02784             i__2 = max(i__3,i__4);
02785             xlaenv_(&c__12, &i__2);
02786             xlaenv_(&c__13, &inwin[i__ - 1]);
02787             xlaenv_(&c__14, &inibl[i__ - 1]);
02788             xlaenv_(&c__15, &ishfts[i__ - 1]);
02789             xlaenv_(&c__16, &iacc22[i__ - 1]);
02790 
02791             if (newsd == 0) {
02792                 for (k = 1; k <= 4; ++k) {
02793                     iseed[k - 1] = ioldsd[k - 1];
02794 /* L260: */
02795                 }
02796             }
02797             s_wsfe(&io___196);
02798             do_fio(&c__1, c3, (ftnlen)3);
02799             do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
02800             do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
02801             do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
02802 /* Computing MAX */
02803             i__3 = 11, i__4 = inmin[i__ - 1];
02804             i__2 = max(i__3,i__4);
02805             do_fio(&c__1, (char *)&i__2, (ftnlen)sizeof(integer));
02806             do_fio(&c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(integer));
02807             do_fio(&c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(integer));
02808             do_fio(&c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(integer));
02809             do_fio(&c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(integer));
02810             e_wsfe();
02811             zchkhs_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, &
02812                     c__132, &a[17424], &a[34848], &a[52272], &a[69696], &
02813                     c__132, &a[87120], &a[104544], dc, &dc[132], &a[121968], &
02814                     a[139392], &a[156816], &a[174240], &a[191664], &dc[264], 
02815                     work, &c__89760, rwork, iwork, logwrk, result, &info);
02816             if (info != 0) {
02817                 s_wsfe(&io___205);
02818                 do_fio(&c__1, "ZCHKHS", (ftnlen)6);
02819                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
02820                 e_wsfe();
02821             }
02822 /* L270: */
02823         }
02824 
02825     } else if (lsamen_(&c__3, c3, "ZST") || lsamen_(&
02826             c__3, c3, "SEP")) {
02827 
02828 /*        ---------------------------------- */
02829 /*        SEP:  Symmetric Eigenvalue Problem */
02830 /*        ---------------------------------- */
02831 /*        Vary the parameters */
02832 /*           NB    = block size */
02833 /*           NBMIN = minimum block size */
02834 /*           NX    = crossover point */
02835 
02836         maxtyp = 21;
02837         ntypes = min(maxtyp,ntypes);
02838         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
02839         xlaenv_(&c__1, &c__1);
02840         xlaenv_(&c__9, &c__25);
02841         if (tsterr) {
02842             zerrst_("ZST", &c__6);
02843         }
02844         i__1 = nparms;
02845         for (i__ = 1; i__ <= i__1; ++i__) {
02846             xlaenv_(&c__1, &nbval[i__ - 1]);
02847             xlaenv_(&c__2, &nbmin[i__ - 1]);
02848             xlaenv_(&c__3, &nxval[i__ - 1]);
02849 
02850             if (newsd == 0) {
02851                 for (k = 1; k <= 4; ++k) {
02852                     iseed[k - 1] = ioldsd[k - 1];
02853 /* L280: */
02854                 }
02855             }
02856             s_wsfe(&io___206);
02857             do_fio(&c__1, c3, (ftnlen)3);
02858             do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
02859             do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
02860             do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
02861             e_wsfe();
02862             if (tstchk) {
02863                 zchkst_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, 
02864                         &c__132, &a[17424], dr, &dr[132], &dr[264], &dr[396], 
02865                         &dr[528], &dr[660], &dr[792], &dr[924], &dr[1056], &
02866                         dr[1188], &dr[1320], &a[34848], &c__132, &a[52272], &
02867                         a[69696], dc, &a[87120], work, &c__89760, rwork, &
02868                         c__89760, iwork, &c__20064, result, &info);
02869                 if (info != 0) {
02870                     s_wsfe(&io___208);
02871                     do_fio(&c__1, "ZCHKST", (ftnlen)6);
02872                     do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
02873                     e_wsfe();
02874                 }
02875             }
02876             if (tstdrv) {
02877                 zdrvst_(&nn, nval, &c__18, dotype, iseed, &thresh, &c__6, a, &
02878                         c__132, &dr[264], &dr[396], &dr[528], &dr[924], &dr[
02879                         1056], &dr[1188], &a[17424], &c__132, &a[34848], dc, &
02880                         a[52272], work, &c__89760, rwork, &c__89760, iwork, &
02881                         c__20064, result, &info);
02882                 if (info != 0) {
02883                     s_wsfe(&io___209);
02884                     do_fio(&c__1, "ZDRVST", (ftnlen)6);
02885                     do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
02886                     e_wsfe();
02887                 }
02888             }
02889 /* L290: */
02890         }
02891 
02892     } else if (lsamen_(&c__3, c3, "ZSG")) {
02893 
02894 /*        ---------------------------------------------- */
02895 /*        ZSG:  Hermitian Generalized Eigenvalue Problem */
02896 /*        ---------------------------------------------- */
02897 /*        Vary the parameters */
02898 /*           NB    = block size */
02899 /*           NBMIN = minimum block size */
02900 /*           NX    = crossover point */
02901 
02902         maxtyp = 21;
02903         ntypes = min(maxtyp,ntypes);
02904         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
02905         xlaenv_(&c__9, &c__25);
02906         i__1 = nparms;
02907         for (i__ = 1; i__ <= i__1; ++i__) {
02908             xlaenv_(&c__1, &nbval[i__ - 1]);
02909             xlaenv_(&c__2, &nbmin[i__ - 1]);
02910             xlaenv_(&c__3, &nxval[i__ - 1]);
02911 
02912             if (newsd == 0) {
02913                 for (k = 1; k <= 4; ++k) {
02914                     iseed[k - 1] = ioldsd[k - 1];
02915 /* L300: */
02916                 }
02917             }
02918             s_wsfe(&io___210);
02919             do_fio(&c__1, c3, (ftnlen)3);
02920             do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
02921             do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
02922             do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
02923             e_wsfe();
02924             if (tstchk) {
02925                 zdrvsg_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, 
02926                         &c__132, &a[17424], &c__132, &dr[264], &a[34848], &
02927                         c__132, &a[52272], &a[69696], &a[87120], &a[104544], 
02928                         work, &c__89760, rwork, &c__89760, iwork, &c__20064, 
02929                         result, &info);
02930                 if (info != 0) {
02931                     s_wsfe(&io___211);
02932                     do_fio(&c__1, "ZDRVSG", (ftnlen)6);
02933                     do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
02934                     e_wsfe();
02935                 }
02936             }
02937 /* L310: */
02938         }
02939 
02940     } else if (lsamen_(&c__3, c3, "ZBD") || lsamen_(&
02941             c__3, c3, "SVD")) {
02942 
02943 /*        ---------------------------------- */
02944 /*        SVD:  Singular Value Decomposition */
02945 /*        ---------------------------------- */
02946 /*        Vary the parameters */
02947 /*           NB    = block size */
02948 /*           NBMIN = minimum block size */
02949 /*           NX    = crossover point */
02950 /*           NRHS  = number of right hand sides */
02951 
02952         maxtyp = 16;
02953         ntypes = min(maxtyp,ntypes);
02954         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
02955         xlaenv_(&c__9, &c__25);
02956 
02957 /*        Test the error exits */
02958 
02959         xlaenv_(&c__1, &c__1);
02960         if (tsterr && tstchk) {
02961             zerrbd_("ZBD", &c__6);
02962         }
02963         if (tsterr && tstdrv) {
02964             zerred_("ZBD", &c__6);
02965         }
02966 
02967         i__1 = nparms;
02968         for (i__ = 1; i__ <= i__1; ++i__) {
02969             nrhs = nsval[i__ - 1];
02970             xlaenv_(&c__1, &nbval[i__ - 1]);
02971             xlaenv_(&c__2, &nbmin[i__ - 1]);
02972             xlaenv_(&c__3, &nxval[i__ - 1]);
02973             if (newsd == 0) {
02974                 for (k = 1; k <= 4; ++k) {
02975                     iseed[k - 1] = ioldsd[k - 1];
02976 /* L320: */
02977                 }
02978             }
02979             s_wsfe(&io___213);
02980             do_fio(&c__1, c3, (ftnlen)3);
02981             do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
02982             do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
02983             do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
02984             do_fio(&c__1, (char *)&nrhs, (ftnlen)sizeof(integer));
02985             e_wsfe();
02986             if (tstchk) {
02987                 zchkbd_(&nn, mval, nval, &maxtyp, dotype, &nrhs, iseed, &
02988                         thresh, a, &c__132, dr, &dr[132], &dr[264], &dr[396], 
02989                         &a[17424], &c__132, &a[34848], &a[52272], &a[69696], &
02990                         c__132, &a[87120], &c__132, &a[104544], &a[121968], 
02991                         work, &c__89760, rwork, &c__6, &info);
02992                 if (info != 0) {
02993                     s_wsfe(&io___214);
02994                     do_fio(&c__1, "ZCHKBD", (ftnlen)6);
02995                     do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
02996                     e_wsfe();
02997                 }
02998             }
02999             if (tstdrv) {
03000                 zdrvbd_(&nn, mval, nval, &maxtyp, dotype, iseed, &thresh, a, &
03001                         c__132, &a[17424], &c__132, &a[34848], &c__132, &a[
03002                         52272], &a[69696], &a[87120], dr, &dr[132], &dr[264], 
03003                         work, &c__89760, rwork, iwork, &c__6, &info);
03004             }
03005 /* L330: */
03006         }
03007 
03008     } else if (lsamen_(&c__3, c3, "ZEV")) {
03009 
03010 /*        -------------------------------------------- */
03011 /*        ZEV:  Nonsymmetric Eigenvalue Problem Driver */
03012 /*              ZGEEV (eigenvalues and eigenvectors) */
03013 /*        -------------------------------------------- */
03014 
03015         maxtyp = 21;
03016         ntypes = min(maxtyp,ntypes);
03017         if (ntypes <= 0) {
03018             s_wsfe(&io___215);
03019             do_fio(&c__1, c3, (ftnlen)3);
03020             e_wsfe();
03021         } else {
03022             if (tsterr) {
03023                 zerred_(c3, &c__6);
03024             }
03025             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03026             zdrvev_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__6, a, &
03027                     c__132, &a[17424], dc, &dc[132], &a[34848], &c__132, &a[
03028                     52272], &c__132, &a[69696], &c__132, result, work, &
03029                     c__89760, rwork, iwork, &info);
03030             if (info != 0) {
03031                 s_wsfe(&io___216);
03032                 do_fio(&c__1, "ZGEEV", (ftnlen)5);
03033                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03034                 e_wsfe();
03035             }
03036         }
03037         s_wsfe(&io___217);
03038         e_wsfe();
03039         goto L10;
03040 
03041     } else if (lsamen_(&c__3, c3, "ZES")) {
03042 
03043 /*        -------------------------------------------- */
03044 /*        ZES:  Nonsymmetric Eigenvalue Problem Driver */
03045 /*              ZGEES (Schur form) */
03046 /*        -------------------------------------------- */
03047 
03048         maxtyp = 21;
03049         ntypes = min(maxtyp,ntypes);
03050         if (ntypes <= 0) {
03051             s_wsfe(&io___218);
03052             do_fio(&c__1, c3, (ftnlen)3);
03053             e_wsfe();
03054         } else {
03055             if (tsterr) {
03056                 zerred_(c3, &c__6);
03057             }
03058             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03059             zdrves_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__6, a, &
03060                     c__132, &a[17424], &a[34848], dc, &dc[132], &a[52272], &
03061                     c__132, result, work, &c__89760, rwork, iwork, logwrk, &
03062                     info);
03063             if (info != 0) {
03064                 s_wsfe(&io___219);
03065                 do_fio(&c__1, "ZGEES", (ftnlen)5);
03066                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03067                 e_wsfe();
03068             }
03069         }
03070         s_wsfe(&io___220);
03071         e_wsfe();
03072         goto L10;
03073 
03074     } else if (lsamen_(&c__3, c3, "ZVX")) {
03075 
03076 /*        -------------------------------------------------------------- */
03077 /*        ZVX:  Nonsymmetric Eigenvalue Problem Expert Driver */
03078 /*              ZGEEVX (eigenvalues, eigenvectors and condition numbers) */
03079 /*        -------------------------------------------------------------- */
03080 
03081         maxtyp = 21;
03082         ntypes = min(maxtyp,ntypes);
03083         if (ntypes < 0) {
03084             s_wsfe(&io___221);
03085             do_fio(&c__1, c3, (ftnlen)3);
03086             e_wsfe();
03087         } else {
03088             if (tsterr) {
03089                 zerred_(c3, &c__6);
03090             }
03091             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03092             zdrvvx_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__5, &c__6, 
03093                     a, &c__132, &a[17424], dc, &dc[132], &a[34848], &c__132, &
03094                     a[52272], &c__132, &a[69696], &c__132, dr, &dr[132], &dr[
03095                     264], &dr[396], &dr[528], &dr[660], &dr[792], &dr[924], 
03096                     result, work, &c__89760, rwork, &info);
03097             if (info != 0) {
03098                 s_wsfe(&io___222);
03099                 do_fio(&c__1, "ZGEEVX", (ftnlen)6);
03100                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03101                 e_wsfe();
03102             }
03103         }
03104         s_wsfe(&io___223);
03105         e_wsfe();
03106         goto L10;
03107 
03108     } else if (lsamen_(&c__3, c3, "ZSX")) {
03109 
03110 /*        --------------------------------------------------- */
03111 /*        ZSX:  Nonsymmetric Eigenvalue Problem Expert Driver */
03112 /*              ZGEESX (Schur form and condition numbers) */
03113 /*        --------------------------------------------------- */
03114 
03115         maxtyp = 21;
03116         ntypes = min(maxtyp,ntypes);
03117         if (ntypes < 0) {
03118             s_wsfe(&io___224);
03119             do_fio(&c__1, c3, (ftnlen)3);
03120             e_wsfe();
03121         } else {
03122             if (tsterr) {
03123                 zerred_(c3, &c__6);
03124             }
03125             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03126             zdrvsx_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__5, &c__6, 
03127                     a, &c__132, &a[17424], &a[34848], dc, &dc[132], &dc[264], 
03128                     &a[52272], &c__132, &a[69696], result, work, &c__89760, 
03129                     rwork, logwrk, &info);
03130             if (info != 0) {
03131                 s_wsfe(&io___225);
03132                 do_fio(&c__1, "ZGEESX", (ftnlen)6);
03133                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03134                 e_wsfe();
03135             }
03136         }
03137         s_wsfe(&io___226);
03138         e_wsfe();
03139         goto L10;
03140 
03141     } else if (lsamen_(&c__3, c3, "ZGG")) {
03142 
03143 /*        ------------------------------------------------- */
03144 /*        ZGG:  Generalized Nonsymmetric Eigenvalue Problem */
03145 /*        ------------------------------------------------- */
03146 /*        Vary the parameters */
03147 /*           NB    = block size */
03148 /*           NBMIN = minimum block size */
03149 /*           NS    = number of shifts */
03150 /*           MAXB  = minimum submatrix size */
03151 /*           NBCOL = minimum column dimension for blocks */
03152 
03153         maxtyp = 26;
03154         ntypes = min(maxtyp,ntypes);
03155         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03156         if (tstchk && tsterr) {
03157             zerrgg_(c3, &c__6);
03158         }
03159         i__1 = nparms;
03160         for (i__ = 1; i__ <= i__1; ++i__) {
03161             xlaenv_(&c__1, &nbval[i__ - 1]);
03162             xlaenv_(&c__2, &nbmin[i__ - 1]);
03163             xlaenv_(&c__4, &nsval[i__ - 1]);
03164             xlaenv_(&c__8, &mxbval[i__ - 1]);
03165             xlaenv_(&c__5, &nbcol[i__ - 1]);
03166 
03167             if (newsd == 0) {
03168                 for (k = 1; k <= 4; ++k) {
03169                     iseed[k - 1] = ioldsd[k - 1];
03170 /* L340: */
03171                 }
03172             }
03173             s_wsfe(&io___227);
03174             do_fio(&c__1, c3, (ftnlen)3);
03175             do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
03176             do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
03177             do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(integer));
03178             do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(integer));
03179             do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(integer));
03180             e_wsfe();
03181             tstdif = FALSE_;
03182             thrshn = 10.;
03183             if (tstchk) {
03184                 zchkgg_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &tstdif, &
03185                         thrshn, &c__6, a, &c__132, &a[17424], &a[34848], &a[
03186                         52272], &a[69696], &a[87120], &a[104544], &a[121968], 
03187                         &a[139392], &c__132, &a[156816], &a[174240], &a[
03188                         191664], dc, &dc[132], &dc[264], &dc[396], &a[209088], 
03189                          &a[226512], work, &c__89760, rwork, logwrk, result, &
03190                         info);
03191                 if (info != 0) {
03192                     s_wsfe(&io___230);
03193                     do_fio(&c__1, "ZCHKGG", (ftnlen)6);
03194                     do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03195                     e_wsfe();
03196                 }
03197             }
03198             xlaenv_(&c__1, &c__1);
03199             if (tstdrv) {
03200                 zdrvgg_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &thrshn, &
03201                         c__6, a, &c__132, &a[17424], &a[34848], &a[52272], &a[
03202                         69696], &a[87120], &a[104544], &c__132, &a[121968], 
03203                         dc, &dc[132], &dc[264], &dc[396], &a[121968], &a[
03204                         139392], work, &c__89760, rwork, result, &info);
03205                 if (info != 0) {
03206                     s_wsfe(&io___231);
03207                     do_fio(&c__1, "ZDRVGG", (ftnlen)6);
03208                     do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03209                     e_wsfe();
03210                 }
03211             }
03212 /* L350: */
03213         }
03214 
03215     } else if (lsamen_(&c__3, c3, "ZGS")) {
03216 
03217 /*        ------------------------------------------------- */
03218 /*        ZGS:  Generalized Nonsymmetric Eigenvalue Problem */
03219 /*              ZGGES (Schur form) */
03220 /*        ------------------------------------------------- */
03221 
03222         maxtyp = 26;
03223         ntypes = min(maxtyp,ntypes);
03224         if (ntypes <= 0) {
03225             s_wsfe(&io___232);
03226             do_fio(&c__1, c3, (ftnlen)3);
03227             e_wsfe();
03228         } else {
03229             if (tsterr) {
03230                 zerrgg_(c3, &c__6);
03231             }
03232             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03233             zdrges_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, &
03234                     c__132, &a[17424], &a[34848], &a[52272], &a[104544], &
03235                     c__132, &a[121968], dc, &dc[132], work, &c__89760, rwork, 
03236                     result, logwrk, &info);
03237 
03238             if (info != 0) {
03239                 s_wsfe(&io___233);
03240                 do_fio(&c__1, "ZDRGES", (ftnlen)6);
03241                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03242                 e_wsfe();
03243             }
03244         }
03245         s_wsfe(&io___234);
03246         e_wsfe();
03247         goto L10;
03248 
03249     } else if (zgx) {
03250 
03251 /*        ------------------------------------------------- */
03252 /*        ZGX  Generalized Nonsymmetric Eigenvalue Problem */
03253 /*              ZGGESX (Schur form and condition numbers) */
03254 /*        ------------------------------------------------- */
03255 
03256         maxtyp = 5;
03257         ntypes = maxtyp;
03258         if (nn < 0) {
03259             s_wsfe(&io___235);
03260             do_fio(&c__1, c3, (ftnlen)3);
03261             e_wsfe();
03262         } else {
03263             if (tsterr) {
03264                 zerrgg_(c3, &c__6);
03265             }
03266             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03267             xlaenv_(&c__5, &c__2);
03268             zdrgsx_(&nn, &c__20, &thresh, &c__5, &c__6, a, &c__132, &a[17424], 
03269                      &a[34848], &a[52272], &a[69696], &a[87120], dc, &dc[132], 
03270                      c__, &c__400, s, work, &c__89760, rwork, iwork, &
03271                     c__20064, logwrk, &info);
03272             if (info != 0) {
03273                 s_wsfe(&io___238);
03274                 do_fio(&c__1, "ZDRGSX", (ftnlen)6);
03275                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03276                 e_wsfe();
03277             }
03278         }
03279         s_wsfe(&io___239);
03280         e_wsfe();
03281         goto L10;
03282 
03283     } else if (lsamen_(&c__3, c3, "ZGV")) {
03284 
03285 /*        ------------------------------------------------- */
03286 /*        ZGV:  Generalized Nonsymmetric Eigenvalue Problem */
03287 /*              ZGGEV (Eigenvalue/vector form) */
03288 /*        ------------------------------------------------- */
03289 
03290         maxtyp = 26;
03291         ntypes = min(maxtyp,ntypes);
03292         if (ntypes <= 0) {
03293             s_wsfe(&io___240);
03294             do_fio(&c__1, c3, (ftnlen)3);
03295             e_wsfe();
03296         } else {
03297             if (tsterr) {
03298                 zerrgg_(c3, &c__6);
03299             }
03300             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03301             zdrgev_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, &
03302                     c__132, &a[17424], &a[34848], &a[52272], &a[104544], &
03303                     c__132, &a[121968], &a[139392], &c__132, dc, &dc[132], &
03304                     dc[264], &dc[396], work, &c__89760, rwork, result, &info);
03305             if (info != 0) {
03306                 s_wsfe(&io___241);
03307                 do_fio(&c__1, "ZDRGEV", (ftnlen)6);
03308                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03309                 e_wsfe();
03310             }
03311         }
03312         s_wsfe(&io___242);
03313         e_wsfe();
03314         goto L10;
03315 
03316     } else if (zxv) {
03317 
03318 /*        ------------------------------------------------- */
03319 /*        ZXV:  Generalized Nonsymmetric Eigenvalue Problem */
03320 /*              ZGGEVX (eigenvalue/vector with condition numbers) */
03321 /*        ------------------------------------------------- */
03322 
03323         maxtyp = 2;
03324         ntypes = maxtyp;
03325         if (nn < 0) {
03326             s_wsfe(&io___243);
03327             do_fio(&c__1, c3, (ftnlen)3);
03328             e_wsfe();
03329         } else {
03330             if (tsterr) {
03331                 zerrgg_(c3, &c__6);
03332             }
03333             alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03334             zdrgvx_(&nn, &thresh, &c__5, &c__6, a, &c__132, &a[17424], &a[
03335                     34848], &a[52272], dc, &dc[132], &a[69696], &a[87120], 
03336                     iwork, &iwork[1], dr, &dr[132], &dr[264], &dr[396], &dr[
03337                     528], &dr[660], work, &c__89760, rwork, &iwork[2], &
03338                     c__20062, result, logwrk, &info);
03339 
03340             if (info != 0) {
03341                 s_wsfe(&io___244);
03342                 do_fio(&c__1, "ZDRGVX", (ftnlen)6);
03343                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03344                 e_wsfe();
03345             }
03346         }
03347         s_wsfe(&io___245);
03348         e_wsfe();
03349         goto L10;
03350 
03351     } else if (lsamen_(&c__3, c3, "ZHB")) {
03352 
03353 /*        ------------------------------ */
03354 /*        ZHB:  Hermitian Band Reduction */
03355 /*        ------------------------------ */
03356 
03357         maxtyp = 15;
03358         ntypes = min(maxtyp,ntypes);
03359         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03360         if (tsterr) {
03361             zerrst_("ZHB", &c__6);
03362         }
03363         zchkhb_(&nn, nval, &nk, kval, &maxtyp, dotype, iseed, &thresh, &c__6, 
03364                 a, &c__132, dr, &dr[132], &a[17424], &c__132, work, &c__89760, 
03365                  rwork, result, &info);
03366         if (info != 0) {
03367             s_wsfe(&io___246);
03368             do_fio(&c__1, "ZCHKHB", (ftnlen)6);
03369             do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03370             e_wsfe();
03371         }
03372 
03373     } else if (lsamen_(&c__3, c3, "ZBB")) {
03374 
03375 /*        ------------------------------ */
03376 /*        ZBB:  General Band Reduction */
03377 /*        ------------------------------ */
03378 
03379         maxtyp = 15;
03380         ntypes = min(maxtyp,ntypes);
03381         alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
03382         i__1 = nparms;
03383         for (i__ = 1; i__ <= i__1; ++i__) {
03384             nrhs = nsval[i__ - 1];
03385 
03386             if (newsd == 0) {
03387                 for (k = 1; k <= 4; ++k) {
03388                     iseed[k - 1] = ioldsd[k - 1];
03389 /* L360: */
03390                 }
03391             }
03392             s_wsfe(&io___247);
03393             do_fio(&c__1, c3, (ftnlen)3);
03394             do_fio(&c__1, (char *)&nrhs, (ftnlen)sizeof(integer));
03395             e_wsfe();
03396             zchkbb_(&nn, mval, nval, &nk, kval, &maxtyp, dotype, &nrhs, iseed, 
03397                      &thresh, &c__6, a, &c__132, &a[17424], &c__264, dr, &dr[
03398                     132], &a[52272], &c__132, &a[69696], &c__132, &a[87120], &
03399                     c__132, &a[104544], work, &c__89760, rwork, result, &info)
03400                     ;
03401             if (info != 0) {
03402                 s_wsfe(&io___248);
03403                 do_fio(&c__1, "ZCHKBB", (ftnlen)6);
03404                 do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03405                 e_wsfe();
03406             }
03407 /* L370: */
03408         }
03409 
03410     } else if (lsamen_(&c__3, c3, "GLM")) {
03411 
03412 /*        ----------------------------------------- */
03413 /*        GLM:  Generalized Linear Regression Model */
03414 /*        ----------------------------------------- */
03415 
03416         xlaenv_(&c__1, &c__1);
03417         if (tsterr) {
03418             zerrgg_("GLM", &c__6);
03419         }
03420         zckglm_(&nn, nval, mval, pval, &ntypes, iseed, &thresh, &c__132, a, &
03421                 a[17424], b, &b[17424], x, work, dr, &c__5, &c__6, &info);
03422         if (info != 0) {
03423             s_wsfe(&io___251);
03424             do_fio(&c__1, "ZCKGLM", (ftnlen)6);
03425             do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03426             e_wsfe();
03427         }
03428 
03429     } else if (lsamen_(&c__3, c3, "GQR")) {
03430 
03431 /*        ------------------------------------------ */
03432 /*        GQR:  Generalized QR and RQ factorizations */
03433 /*        ------------------------------------------ */
03434 
03435         xlaenv_(&c__1, &c__1);
03436         if (tsterr) {
03437             zerrgg_("GQR", &c__6);
03438         }
03439         zckgqr_(&nn, mval, &nn, pval, &nn, nval, &ntypes, iseed, &thresh, &
03440                 c__132, a, &a[17424], &a[34848], &a[52272], taua, b, &b[17424]
03441 , &b[34848], &b[52272], &b[69696], taub, work, dr, &c__5, &
03442                 c__6, &info);
03443         if (info != 0) {
03444             s_wsfe(&io___254);
03445             do_fio(&c__1, "ZCKGQR", (ftnlen)6);
03446             do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03447             e_wsfe();
03448         }
03449 
03450     } else if (lsamen_(&c__3, c3, "GSV")) {
03451 
03452 /*        ---------------------------------------------- */
03453 /*        GSV:  Generalized Singular Value Decomposition */
03454 /*        ---------------------------------------------- */
03455 
03456         if (tsterr) {
03457             zerrgg_("GSV", &c__6);
03458         }
03459         zckgsv_(&nn, mval, pval, nval, &ntypes, iseed, &thresh, &c__132, a, &
03460                 a[17424], b, &b[17424], &a[34848], &b[34848], &a[52272], 
03461                 alpha, beta, &b[52272], iwork, work, dr, &c__5, &c__6, &info);
03462         if (info != 0) {
03463             s_wsfe(&io___257);
03464             do_fio(&c__1, "ZCKGSV", (ftnlen)6);
03465             do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03466             e_wsfe();
03467         }
03468 
03469     } else if (lsamen_(&c__3, c3, "LSE")) {
03470 
03471 /*        -------------------------------------- */
03472 /*        LSE:  Constrained Linear Least Squares */
03473 /*        -------------------------------------- */
03474 
03475         xlaenv_(&c__1, &c__1);
03476         if (tsterr) {
03477             zerrgg_("LSE", &c__6);
03478         }
03479         zcklse_(&nn, mval, pval, nval, &ntypes, iseed, &thresh, &c__132, a, &
03480                 a[17424], b, &b[17424], x, work, dr, &c__5, &c__6, &info);
03481         if (info != 0) {
03482             s_wsfe(&io___258);
03483             do_fio(&c__1, "ZCKLSE", (ftnlen)6);
03484             do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
03485             e_wsfe();
03486         }
03487     } else {
03488         s_wsle(&io___259);
03489         e_wsle();
03490         s_wsle(&io___260);
03491         e_wsle();
03492         s_wsfe(&io___261);
03493         do_fio(&c__1, c3, (ftnlen)3);
03494         e_wsfe();
03495     }
03496     if (! (zgx || zxv)) {
03497         goto L190;
03498     }
03499 L380:
03500     s_wsfe(&io___262);
03501     e_wsfe();
03502     s2 = dsecnd_();
03503     s_wsfe(&io___264);
03504     d__1 = s2 - s1;
03505     do_fio(&c__1, (char *)&d__1, (ftnlen)sizeof(doublereal));
03506     e_wsfe();
03507 
03508 /* L9998: */
03509 
03510 /*     End of ZCHKEE */
03511 
03512     return 0;
03513 } /* MAIN__ */
03514 
03515 /* Main program alias */ int zchkee_ () { MAIN__ (); return 0; }


swiftnav
Author(s):
autogenerated on Sat Jun 8 2019 18:56:18