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


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