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


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