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


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