PageRenderTime 66ms CodeModel.GetById 29ms RepoModel.GetById 1ms app.codeStats 0ms

/thirdPartyCode/CLAPACK/TESTING/EIG/dchkee.c

https://bitbucket.org/rutad/libs
C | 3127 lines | 1825 code | 172 blank | 1130 comment | 390 complexity | 28d96679865987373a96538864497978 MD5 | raw file
Possible License(s): BSD-3-Clause, MPL-2.0-no-copyleft-exception, GPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. #include "blaswrap.h"
    2. 

  2. /*  -- translated by f2c (version 19990503).
    3. 

  3.    You must link the resulting object file with the libraries:
    4. 

  4. 	-lf2c -lm   (in that order)
    5. 

  5. */
    6. 

  6. 

  7. #include "f2c.h"
    8. 

  8. 

  9. /* Common Block Declarations */
    10. 

  10. 

  11. struct {
    12. 

  12.     integer nproc, nshift, maxb;
    13. 

  13. } cenvir_;
    14. 

  14. 

  15. #define cenvir_1 cenvir_
    16. 

  16. 

  17. struct {
    18. 

  18.     integer infot, nunit;
    19. 

  19.     logical ok, lerr;
    20. 

  20. } infoc_;
    21. 

  21. 

  22. #define infoc_1 infoc_
    23. 

  23. 

  24. struct {
    25. 

  25.     char srnamt[6];
    26. 

  26. } srnamc_;
    27. 

  27. 

  28. #define srnamc_1 srnamc_
    29. 

  29. 

  30. struct {
    31. 

  31.     integer selopt, seldim;
    32. 

  32.     logical selval[20];
    33. 

  33.     doublereal selwr[20], selwi[20];
    34. 

  34. } sslct_;
    35. 

  35. 

  36. #define sslct_1 sslct_
    37. 

  37. 

  38. struct {
    39. 

  39.     integer iparms[100];
    40. 

  40. } zlaenv_;
    41. 

  41. 

  42. #define zlaenv_1 zlaenv_
    43. 

  43. 

  44. /* Table of constant values */
    45. 

  45. 

  46. static integer c__1 = 1;
    47. 

  47. static integer c__3 = 3;
    48. 

  48. static integer c__5 = 5;
    49. 

  49. static integer c__6 = 6;
    50. 

  50. static integer c__20 = 20;
    51. 

  51. static integer c__0 = 0;
    52. 

  52. static integer c__132 = 132;
    53. 

  53. static integer c__2 = 2;
    54. 

  54. static integer c__4 = 4;
    55. 

  55. static integer c__8 = 8;
    56. 

  56. static integer c__87781 = 87781;
    57. 

  57. static integer c__9 = 9;
    58. 

  58. static integer c__25 = 25;
    59. 

  59. static integer c__89760 = 89760;
    60. 

  60. static integer c__18 = 18;
    61. 

  61. static integer c__400 = 400;
    62. 

  62. static integer c__89758 = 89758;
    63. 

  63. static integer c__264 = 264;
    64. 

  64. 

  65. /* Main program */ MAIN__(void)
    66. 

  66. {
    67. 

  67.     /* Initialized data */
    68. 

  68. 

  69.     static char intstr[10] = "0123456789";
    70. 

  70.     static integer ioldsd[4] = { 0,0,0,1 };
    71. 

  71. 

  72.     /* Format strings */
    73. 

  73.     static char fmt_9987[] = "(\002 Tests of the Nonsymmetric Eigenvalue Pro"
    74. 

  74. 	    "blem routines\002)";
    75. 

  75.     static char fmt_9986[] = "(\002 Tests of the Symmetric Eigenvalue Proble"
    76. 

  76. 	    "m routines\002)";
    77. 

  77.     static char fmt_9985[] = "(\002 Tests of the Singular Value Decompositio"
    78. 

  78. 	    "n routines\002)";
    79. 

  79.     static char fmt_9979[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
    80. 

  80. 	    "oblem Driver\002,/\002    DGEEV (eigenvalues and eigevectors)"
    81. 

  81. 	    "\002)";
    82. 

  82.     static char fmt_9978[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
    83. 

  83. 	    "oblem Driver\002,/\002    DGEES (Schur form)\002)";
    84. 

  84.     static char fmt_9977[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
    85. 

  85. 	    "oblem Expert\002,\002 Driver\002,/\002    DGEEVX (eigenvalues, e"
    86. 

  86. 	    "igenvectors and\002,\002 condition numbers)\002)";
    87. 

  87.     static char fmt_9976[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
    88. 

  88. 	    "oblem Expert\002,\002 Driver\002,/\002    DGEESX (Schur form and"
    89. 

  89. 	    " condition\002,\002 numbers)\002)";
    90. 

  90.     static char fmt_9975[] = "(/\002 Tests of the Generalized Nonsymmetric E"
    91. 

  91. 	    "igenvalue \002,\002Problem routines\002)";
    92. 

  92.     static char fmt_9964[] = "(/\002 Tests of the Generalized Nonsymmetric E"
    93. 

  93. 	    "igenvalue \002,\002Problem Driver DGGES\002)";
    94. 

  94.     static char fmt_9965[] = "(/\002 Tests of the Generalized Nonsymmetric E"
    95. 

  95. 	    "igenvalue \002,\002Problem Expert Driver DGGESX\002)";
    96. 

  96.     static char fmt_9963[] = "(/\002 Tests of the Generalized Nonsymmetric E"
    97. 

  97. 	    "igenvalue \002,\002Problem Driver DGGEV\002)";
    98. 

  98.     static char fmt_9962[] = "(/\002 Tests of the Generalized Nonsymmetric E"
    99. 

  99. 	    "igenvalue \002,\002Problem Expert Driver DGGEVX\002)";
    100. 

  100.     static char fmt_9974[] = "(\002 Tests of DSBTRD\002,/\002 (reduction of "
    101. 

  101. 	    "a symmetric band \002,\002matrix to tridiagonal form)\002)";
    102. 

  102.     static char fmt_9967[] = "(\002 Tests of DGBBRD\002,/\002 (reduction of "
    103. 

  103. 	    "a general band \002,\002matrix to real bidiagonal form)\002)";
    104. 

  104.     static char fmt_9971[] = "(/\002 Tests of the Generalized Linear Regress"
    105. 

  105. 	    "ion Model \002,\002routines\002)";
    106. 

  106.     static char fmt_9970[] = "(/\002 Tests of the Generalized QR and RQ rout"
    107. 

  107. 	    "ines\002)";
    108. 

  108.     static char fmt_9969[] = "(/\002 Tests of the Generalized Singular Valu"
    109. 

  109. 	    "e\002,\002 Decomposition routines\002)";
    110. 

  110.     static char fmt_9968[] = "(/\002 Tests of the Linear Least Squares routi"
    111. 

  111. 	    "nes\002)";
    112. 

  112.     static char fmt_9992[] = "(1x,a3,\002:  Unrecognized path name\002)";
    113. 

  113.     static char fmt_9972[] = "(/\002 LAPACK VERSION 3.0, released June 30, 1"
    114. 

  114. 	    "999 \002)";
    115. 

  115.     static char fmt_9984[] = "(/\002 The following parameter values will be "
    116. 

  116. 	    "used:\002)";
    117. 

  117.     static char fmt_9989[] = "(\002 Invalid input value: \002,a6,\002=\002,i"
    118. 

  118. 	    "6,\002; must be >=\002,i6)";
    119. 

  119.     static char fmt_9988[] = "(\002 Invalid input value: \002,a6,\002=\002,i"
    120. 

  120. 	    "6,\002; must be <=\002,i6)";
    121. 

  121.     static char fmt_9983[] = "(4x,a6,10i6,/10x,10i6)";
    122. 

  122.     static char fmt_9981[] = "(\002 Relative machine \002,a,\002 is taken to"
    123. 

  123. 	    " be\002,d16.6)";
    124. 

  124.     static char fmt_9982[] = "(/\002 Routines pass computational tests if te"
    125. 

  125. 	    "st ratio is \002,\002less than\002,f8.2,/)";
    126. 

  126.     static char fmt_9999[] = "(/\002 Execution not attempted due to input er"
    127. 

  127. 	    "rors\002)";
    128. 

  128.     static char fmt_9991[] = "(//\002 *** Invalid integer value in column"
    129. 

  129. 	    " \002,i2,\002 of input\002,\002 line:\002,/a79)";
    130. 

  130.     static char fmt_9990[] = "(//1x,a3,\002 routines were not tested\002)";
    131. 

  131.     static char fmt_9998[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
    132. 

  132. 	    "i4,\002, NX =\002,i4,\002, NS =\002,i4,\002, MAXB =\002,i4)";
    133. 

  133.     static char fmt_9980[] = "(\002 *** Error code from \002,a6,\002 = \002,"
    134. 

  134. 	    "i4)";
    135. 

  135.     static char fmt_9997[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
    136. 

  136. 	    "i4,\002, NX =\002,i4)";
    137. 

  137.     static char fmt_9995[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
    138. 

  138. 	    "i4,\002, NX =\002,i4,\002, NRHS =\002,i4)";
    139. 

  139.     static char fmt_9973[] = "(/1x,71(\002-\002))";
    140. 

  140.     static char fmt_9996[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
    141. 

  141. 	    "i4,\002, NS =\002,i4,\002, MAXB =\002,i4,\002, NBCOL =\002,i4)";
    142. 

  142.     static char fmt_9966[] = "(//1x,a3,\002:  NRHS =\002,i4)";
    143. 

  143.     static char fmt_9994[] = "(//\002 End of tests\002)";
    144. 

  144.     static char fmt_9993[] = "(\002 Total time used = \002,f12.2,\002 seco"
    145. 

  145. 	    "nds\002,/)";
    146. 

  146. 

  147.     /* System generated locals */
    148. 

  148.     integer i__1;
    149. 

  149.     doublereal d__1;
    150. 

  150. 

  151.     /* Builtin functions */
    152. 

  152.     integer s_rsfe(cilist *), do_fio(integer *, char *, ftnlen), e_rsfe(void);
    153. 

  153.     /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    154. 

  154.     integer s_cmp(char *, char *, ftnlen, ftnlen), s_wsfe(cilist *), e_wsfe(
    155. 

  155. 	    void), s_rsle(cilist *), do_lio(integer *, integer *, char *, 
    156. 

  156. 	    ftnlen), e_rsle(void), s_wsle(cilist *), e_wsle(void);
    157. 

  157.     /* Subroutine */ int s_stop(char *, ftnlen);
    158. 

  158.     integer i_len(char *, ftnlen);
    159. 

  159. 

  160.     /* Local variables */
    161. 

  161.     static char line[80];
    162. 

  162.     static doublereal taua[132];
    163. 

  163.     static integer info;
    164. 

  164.     static char path[3];
    165. 

  165.     static integer kval[20], lenp, mval[20], nval[20];
    166. 

  166.     static doublereal taub[132];
    167. 

  167.     static integer pval[20], itmp, nrhs;
    168. 

  168.     static doublereal work[87781], a[243936]	/* was [17424][14] */, b[
    169. 

  169. 	    87120]	/* was [17424][5] */, c__[160000]	/* was [400][
    170. 

  170. 	    400] */, d__[1584]	/* was [132][12] */;
    171. 

  171.     static integer i__, k;
    172. 

  172.     static logical fatal;
    173. 

  173.     static doublereal x[660];
    174. 

  174.     static integer iseed[4], nbcol[20], nbval[20], nbmin[20];
    175. 

  175.     static char vname[6];
    176. 

  176.     static integer newsd, nsval[20];
    177. 

  177.     static char c1[1], c3[3];
    178. 

  178.     static integer nxval[20], i1, iwork[89760];
    179. 

  179.     static doublereal s1, s2;
    180. 

  180.     static integer ic;
    181. 

  181.     extern /* Subroutine */ int dchkbb_(integer *, integer *, integer *, 
    182. 

  182. 	    integer *, integer *, integer *, logical *, integer *, integer *, 
    183. 

  183. 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
    184. 

  184. 	    integer *, doublereal *, doublereal *, doublereal *, integer *, 
    185. 

  185. 	    doublereal *, integer *, doublereal *, integer *, doublereal *, 
    186. 

  186. 	    doublereal *, integer *, doublereal *, integer *), dchkbd_(
    187. 

  187. 	    integer *, integer *, integer *, integer *, logical *, integer *, 
    188. 

  188. 	    integer *, doublereal *, doublereal *, integer *, doublereal *, 
    189. 

  189. 	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
    190. 

  190. 	     doublereal *, doublereal *, doublereal *, integer *, doublereal *
    191. 

  191. 	    , integer *, doublereal *, doublereal *, doublereal *, integer *, 
    192. 

  192. 	    integer *, integer *, integer *), dchkec_(doublereal *, logical *,
    193. 

  193. 	     integer *, integer *), dchkbk_(integer *, integer *), dchkbl_(
    194. 

  194. 	    integer *, integer *);
    195. 

  195.     extern doublereal dlamch_(char *);
    196. 

  196.     static integer nk;
    197. 

  197.     extern /* Subroutine */ int dchkgg_(integer *, integer *, integer *, 
    198. 

  198. 	    logical *, integer *, doublereal *, logical *, doublereal *, 
    199. 

  199. 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
    200. 

  200. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    201. 

  201. 	    doublereal *, doublereal *, integer *, doublereal *, doublereal *,
    202. 

  202. 	     doublereal *, doublereal *, doublereal *, doublereal *, 
    203. 

  203. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    204. 

  204. 	    doublereal *, doublereal *, integer *, logical *, doublereal *, 
    205. 

  205. 	    integer *), dchkgk_(integer *, integer *);
    206. 

  206.     static integer nn;
    207. 

  207.     extern /* Subroutine */ int dchkgl_(integer *, integer *), dchksb_(
    208. 

  208. 	    integer *, integer *, integer *, integer *, integer *, logical *, 
    209. 

  209. 	    integer *, doublereal *, integer *, doublereal *, integer *, 
    210. 

  210. 	    doublereal *, doublereal *, doublereal *, integer *, doublereal *,
    211. 

  211. 	     integer *, doublereal *, integer *);
    212. 

  212.     extern doublereal dsecnd_(void);
    213. 

  213.     extern /* Subroutine */ int dckglm_(integer *, integer *, integer *, 
    214. 

  214. 	    integer *, integer *, integer *, doublereal *, integer *, 
    215. 

  215. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    216. 

  216. 	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
    217. 

  217. 	    integer *), derrbd_(char *, integer *), dchkhs_(integer *,
    218. 

  218. 	     integer *, integer *, logical *, integer *, doublereal *, 
    219. 

  219. 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
    220. 

  220. 	    doublereal *, doublereal *, integer *, doublereal *, doublereal *,
    221. 

  221. 	     doublereal *, doublereal *, doublereal *, doublereal *, 
    222. 

  222. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    223. 

  223. 	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
    224. 

  224. 	    logical *, doublereal *, integer *), alareq_(char *, integer *, 
    225. 

  225. 	    logical *, integer *, integer *, integer *), dcklse_(
    226. 

  226. 	    integer *, integer *, integer *, integer *, integer *, integer *, 
    227. 

  227. 	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
    228. 

  228. 	     doublereal *, doublereal *, doublereal *, doublereal *, integer *
    229. 

  229. 	    , integer *, integer *), ddrvbd_(integer *, integer *, integer *, 
    230. 

  230. 	    integer *, logical *, integer *, doublereal *, doublereal *, 
    231. 

  231. 	    integer *, doublereal *, integer *, doublereal *, integer *, 
    232. 

  232. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    233. 

  233. 	    doublereal *, doublereal *, doublereal *, integer *, integer *, 
    234. 

  234. 	    integer *, integer *), ddrges_(integer *, integer *, integer *, 
    235. 

  235. 	    logical *, integer *, doublereal *, integer *, doublereal *, 
    236. 

  236. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    237. 

  237. 	     integer *, doublereal *, doublereal *, doublereal *, doublereal *
    238. 

  238. 	    , doublereal *, integer *, doublereal *, logical *, integer *), 
    239. 

  239. 	    derred_(char *, integer *), derrgg_(char *, integer *), dckgqr_(integer *, integer *, integer *, integer *, 
    240. 

  240. 	    integer *, integer *, integer *, integer *, doublereal *, integer 
    241. 

  241. 	    *, doublereal *, doublereal *, doublereal *, doublereal *, 
    242. 

  242. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    243. 

  243. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    244. 

  244. 	    doublereal *, integer *, integer *, integer *), ddrgev_(integer *,
    245. 

  245. 	     integer *, integer *, logical *, integer *, doublereal *, 
    246. 

  246. 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
    247. 

  247. 	    doublereal *, doublereal *, integer *, doublereal *, doublereal *,
    248. 

  248. 	     integer *, doublereal *, doublereal *, doublereal *, doublereal *
    249. 

  249. 	    , doublereal *, doublereal *, doublereal *, integer *, doublereal 
    250. 

  250. 	    *, integer *), ddrvgg_(integer *, integer *, integer *, logical *,
    251. 

  251. 	     integer *, doublereal *, doublereal *, integer *, doublereal *, 
    252. 

  252. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    253. 

  253. 	     doublereal *, doublereal *, integer *, doublereal *, doublereal *
    254. 

  254. 	    , doublereal *, doublereal *, doublereal *, doublereal *, 
    255. 

  255. 	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
    256. 

  256. 	     doublereal *, integer *);
    257. 

  257.     extern logical lsamen_(integer *, char *, char *);
    258. 

  258.     extern /* Subroutine */ int dchkst_(integer *, integer *, integer *, 
    259. 

  259. 	    logical *, integer *, doublereal *, integer *, doublereal *, 
    260. 

  260. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    261. 

  261. 	     doublereal *, doublereal *, doublereal *, doublereal *, 
    262. 

  262. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    263. 

  263. 	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
    264. 

  264. 	     doublereal *, doublereal *, integer *, integer *, integer *, 
    265. 

  265. 	    doublereal *, integer *), dckgsv_(integer *, integer *, integer *,
    266. 

  266. 	     integer *, integer *, integer *, doublereal *, integer *, 
    267. 

  267. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    268. 

  268. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    269. 

  269. 	    doublereal *, doublereal *, integer *, doublereal *, doublereal *,
    270. 

  270. 	     integer *, integer *, integer *), ddrves_(integer *, integer *, 
    271. 

  271. 	    integer *, logical *, integer *, doublereal *, integer *, 
    272. 

  272. 	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
    273. 

  273. 	     doublereal *, doublereal *, doublereal *, doublereal *, integer *
    274. 

  274. 	    , doublereal *, doublereal *, integer *, integer *, logical *, 
    275. 

  275. 	    integer *), derrhs_(char *, integer *);
    276. 

  276.     static integer mxbval[20];
    277. 

  277.     extern /* Subroutine */ int ddrvev_(integer *, integer *, integer *, 
    278. 

  278. 	    logical *, integer *, doublereal *, integer *, doublereal *, 
    279. 

  279. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    280. 

  280. 	     doublereal *, doublereal *, integer *, doublereal *, integer *, 
    281. 

  281. 	    doublereal *, integer *, doublereal *, doublereal *, integer *, 
    282. 

  282. 	    integer *, integer *), ddrgsx_(integer *, integer *, doublereal *,
    283. 

  283. 	     integer *, integer *, doublereal *, integer *, doublereal *, 
    284. 

  284. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    285. 

  285. 	    doublereal *, doublereal *, doublereal *, doublereal *, integer *,
    286. 

  286. 	     doublereal *, doublereal *, integer *, integer *, integer *, 
    287. 

  287. 	    logical *, integer *), ddrvsg_(integer *, integer *, integer *, 
    288. 

  288. 	    logical *, integer *, doublereal *, integer *, doublereal *, 
    289. 

  289. 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
    290. 

  290. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    291. 

  291. 	     doublereal *, integer *, integer *, integer *, doublereal *, 
    292. 

  292. 	    integer *);
    293. 

  293.     static logical tstdif;
    294. 

  294.     static doublereal thresh;
    295. 

  295.     extern /* Subroutine */ int ddrgvx_(integer *, doublereal *, integer *, 
    296. 

  296. 	    integer *, doublereal *, integer *, doublereal *, doublereal *, 
    297. 

  297. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    298. 

  298. 	    doublereal *, doublereal *, integer *, integer *, doublereal *, 
    299. 

  299. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    300. 

  300. 	    doublereal *, doublereal *, integer *, integer *, integer *, 
    301. 

  301. 	    doublereal *, logical *, integer *);
    302. 

  302.     static logical tstchk;
    303. 

  303.     static integer nparms;
    304. 

  304.     extern /* Subroutine */ int xlaenv_(integer *, integer *), derrst_(char *,
    305. 

  305. 	     integer *);
    306. 

  306.     static logical dotype[30], logwrk[132];
    307. 

  307.     static doublereal thrshn;
    308. 

  308.     extern /* Subroutine */ int ddrvst_(integer *, integer *, integer *, 
    309. 

  309. 	    logical *, integer *, doublereal *, integer *, doublereal *, 
    310. 

  310. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    311. 

  311. 	     doublereal *, doublereal *, doublereal *, doublereal *, 
    312. 

  312. 	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
    313. 

  313. 	     doublereal *, integer *, integer *, integer *, doublereal *, 
    314. 

  314. 	    integer *), ddrvsx_(integer *, integer *, integer *, logical *, 
    315. 

  315. 	    integer *, doublereal *, integer *, integer *, doublereal *, 
    316. 

  316. 	    integer *, doublereal *, doublereal *, doublereal *, doublereal *,
    317. 

  317. 	     doublereal *, doublereal *, doublereal *, doublereal *, 
    318. 

  318. 	    doublereal *, integer *, doublereal *, doublereal *, doublereal *,
    319. 

  319. 	     integer *, integer *, logical *, integer *), ddrvvx_(integer *, 
    320. 

  320. 	    integer *, integer *, logical *, integer *, doublereal *, integer 
    321. 

  321. 	    *, integer *, doublereal *, integer *, doublereal *, doublereal *,
    322. 

  322. 	     doublereal *, doublereal *, doublereal *, doublereal *, integer *
    323. 

  323. 	    , doublereal *, integer *, doublereal *, integer *, doublereal *, 
    324. 

  324. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    325. 

  325. 	    doublereal *, doublereal *, doublereal *, doublereal *, 
    326. 

  326. 	    doublereal *, integer *, integer *, integer *);
    327. 

  327.     static doublereal result[500];
    328. 

  328.     static integer maxtyp;
    329. 

  329.     static logical tsterr;
    330. 

  330.     static integer ntypes;
    331. 

  331.     static logical tstdrv, dbb, dbk, dgg, dbl, dgk, dgl, dsb, des, dgs, dev, 
    332. 

  332. 	    glm, dgv, nep, lse, dgx, sep;
    333. 

  333.     static doublereal eps;
    334. 

  334.     static logical gqr, svd, dsx, gsv, dvx, dxv;
    335. 

  335. 

  336.     /* Fortran I/O blocks */
    337. 

  337.     static cilist io___5 = { 0, 5, 1, "(A80)", 0 };
    338. 

  338.     static cilist io___30 = { 0, 6, 0, fmt_9987, 0 };
    339. 

  339.     static cilist io___31 = { 0, 6, 0, fmt_9986, 0 };
    340. 

  340.     static cilist io___32 = { 0, 6, 0, fmt_9985, 0 };
    341. 

  341.     static cilist io___33 = { 0, 6, 0, fmt_9979, 0 };
    342. 

  342.     static cilist io___34 = { 0, 6, 0, fmt_9978, 0 };
    343. 

  343.     static cilist io___35 = { 0, 6, 0, fmt_9977, 0 };
    344. 

  344.     static cilist io___36 = { 0, 6, 0, fmt_9976, 0 };
    345. 

  345.     static cilist io___37 = { 0, 6, 0, fmt_9975, 0 };
    346. 

  346.     static cilist io___38 = { 0, 6, 0, fmt_9964, 0 };
    347. 

  347.     static cilist io___39 = { 0, 6, 0, fmt_9965, 0 };
    348. 

  348.     static cilist io___40 = { 0, 6, 0, fmt_9963, 0 };
    349. 

  349.     static cilist io___41 = { 0, 6, 0, fmt_9962, 0 };
    350. 

  350.     static cilist io___42 = { 0, 6, 0, fmt_9974, 0 };
    351. 

  351.     static cilist io___43 = { 0, 6, 0, fmt_9967, 0 };
    352. 

  352.     static cilist io___44 = { 0, 6, 0, fmt_9971, 0 };
    353. 

  353.     static cilist io___45 = { 0, 6, 0, fmt_9970, 0 };
    354. 

  354.     static cilist io___46 = { 0, 6, 0, fmt_9969, 0 };
    355. 

  355.     static cilist io___47 = { 0, 6, 0, fmt_9968, 0 };
    356. 

  356.     static cilist io___48 = { 0, 5, 0, 0, 0 };
    357. 

  357.     static cilist io___51 = { 0, 6, 0, fmt_9992, 0 };
    358. 

  358.     static cilist io___52 = { 0, 6, 0, fmt_9972, 0 };
    359. 

  359.     static cilist io___53 = { 0, 6, 0, fmt_9984, 0 };
    360. 

  360.     static cilist io___54 = { 0, 5, 0, 0, 0 };
    361. 

  361.     static cilist io___56 = { 0, 6, 0, fmt_9989, 0 };
    362. 

  362.     static cilist io___57 = { 0, 6, 0, fmt_9988, 0 };
    363. 

  363.     static cilist io___58 = { 0, 5, 0, 0, 0 };
    364. 

  364.     static cilist io___62 = { 0, 6, 0, fmt_9989, 0 };
    365. 

  365.     static cilist io___63 = { 0, 6, 0, fmt_9988, 0 };
    366. 

  366.     static cilist io___64 = { 0, 6, 0, fmt_9983, 0 };
    367. 

  367.     static cilist io___65 = { 0, 5, 0, 0, 0 };
    368. 

  368.     static cilist io___67 = { 0, 6, 0, fmt_9989, 0 };
    369. 

  369.     static cilist io___68 = { 0, 6, 0, fmt_9988, 0 };
    370. 

  370.     static cilist io___69 = { 0, 6, 0, fmt_9983, 0 };
    371. 

  371.     static cilist io___70 = { 0, 5, 0, 0, 0 };
    372. 

  372.     static cilist io___72 = { 0, 6, 0, fmt_9989, 0 };
    373. 

  373.     static cilist io___73 = { 0, 6, 0, fmt_9988, 0 };
    374. 

  374.     static cilist io___74 = { 0, 6, 0, fmt_9983, 0 };
    375. 

  375.     static cilist io___75 = { 0, 6, 0, fmt_9983, 0 };
    376. 

  376.     static cilist io___76 = { 0, 5, 0, 0, 0 };
    377. 

  377.     static cilist io___78 = { 0, 5, 0, 0, 0 };
    378. 

  378.     static cilist io___80 = { 0, 6, 0, fmt_9989, 0 };
    379. 

  379.     static cilist io___81 = { 0, 6, 0, fmt_9988, 0 };
    380. 

  380.     static cilist io___82 = { 0, 6, 0, fmt_9983, 0 };
    381. 

  381.     static cilist io___83 = { 0, 5, 0, 0, 0 };
    382. 

  382.     static cilist io___89 = { 0, 6, 0, fmt_9989, 0 };
    383. 

  383.     static cilist io___90 = { 0, 6, 0, fmt_9989, 0 };
    384. 

  384.     static cilist io___91 = { 0, 6, 0, fmt_9989, 0 };
    385. 

  385.     static cilist io___92 = { 0, 6, 0, fmt_9989, 0 };
    386. 

  386.     static cilist io___93 = { 0, 6, 0, fmt_9989, 0 };
    387. 

  387.     static cilist io___94 = { 0, 6, 0, fmt_9983, 0 };
    388. 

  388.     static cilist io___95 = { 0, 6, 0, fmt_9983, 0 };
    389. 

  389.     static cilist io___96 = { 0, 6, 0, fmt_9983, 0 };
    390. 

  390.     static cilist io___97 = { 0, 6, 0, fmt_9983, 0 };
    391. 

  391.     static cilist io___98 = { 0, 6, 0, fmt_9983, 0 };
    392. 

  392.     static cilist io___99 = { 0, 5, 0, 0, 0 };
    393. 

  393.     static cilist io___101 = { 0, 6, 0, fmt_9989, 0 };
    394. 

  394.     static cilist io___102 = { 0, 6, 0, fmt_9988, 0 };
    395. 

  395.     static cilist io___103 = { 0, 5, 0, 0, 0 };
    396. 

  396.     static cilist io___104 = { 0, 6, 0, fmt_9989, 0 };
    397. 

  397.     static cilist io___105 = { 0, 6, 0, fmt_9988, 0 };
    398. 

  398.     static cilist io___106 = { 0, 6, 0, fmt_9983, 0 };
    399. 

  399.     static cilist io___107 = { 0, 5, 0, 0, 0 };
    400. 

  400.     static cilist io___108 = { 0, 6, 0, fmt_9989, 0 };
    401. 

  401.     static cilist io___109 = { 0, 6, 0, fmt_9988, 0 };
    402. 

  402.     static cilist io___110 = { 0, 6, 0, fmt_9983, 0 };
    403. 

  403.     static cilist io___111 = { 0, 5, 0, 0, 0 };
    404. 

  404.     static cilist io___112 = { 0, 6, 0, fmt_9989, 0 };
    405. 

  405.     static cilist io___113 = { 0, 6, 0, fmt_9988, 0 };
    406. 

  406.     static cilist io___114 = { 0, 6, 0, fmt_9983, 0 };
    407. 

  407.     static cilist io___115 = { 0, 5, 0, 0, 0 };
    408. 

  408.     static cilist io___116 = { 0, 6, 0, fmt_9989, 0 };
    409. 

  409.     static cilist io___117 = { 0, 6, 0, fmt_9988, 0 };
    410. 

  410.     static cilist io___118 = { 0, 6, 0, fmt_9983, 0 };
    411. 

  411.     static cilist io___119 = { 0, 5, 0, 0, 0 };
    412. 

  412.     static cilist io___120 = { 0, 6, 0, fmt_9989, 0 };
    413. 

  413.     static cilist io___121 = { 0, 6, 0, fmt_9988, 0 };
    414. 

  414.     static cilist io___122 = { 0, 6, 0, fmt_9983, 0 };
    415. 

  415.     static cilist io___123 = { 0, 5, 0, 0, 0 };
    416. 

  416.     static cilist io___125 = { 0, 6, 0, fmt_9989, 0 };
    417. 

  417.     static cilist io___126 = { 0, 6, 0, fmt_9988, 0 };
    418. 

  418.     static cilist io___127 = { 0, 6, 0, fmt_9983, 0 };
    419. 

  419.     static cilist io___128 = { 0, 6, 0, 0, 0 };
    420. 

  420.     static cilist io___130 = { 0, 6, 0, fmt_9981, 0 };
    421. 

  421.     static cilist io___131 = { 0, 6, 0, fmt_9981, 0 };
    422. 

  422.     static cilist io___132 = { 0, 6, 0, fmt_9981, 0 };
    423. 

  423.     static cilist io___133 = { 0, 5, 0, 0, 0 };
    424. 

  424.     static cilist io___134 = { 0, 6, 0, fmt_9982, 0 };
    425. 

  425.     static cilist io___135 = { 0, 5, 0, 0, 0 };
    426. 

  426.     static cilist io___137 = { 0, 5, 0, 0, 0 };
    427. 

  427.     static cilist io___139 = { 0, 5, 0, 0, 0 };
    428. 

  428.     static cilist io___140 = { 0, 5, 0, 0, 0 };
    429. 

  429.     static cilist io___142 = { 0, 5, 0, 0, 0 };
    430. 

  430.     static cilist io___144 = { 0, 6, 0, fmt_9999, 0 };
    431. 

  431.     static cilist io___145 = { 0, 5, 1, "(A80)", 0 };
    432. 

  432.     static cilist io___154 = { 0, 6, 0, fmt_9991, 0 };
    433. 

  433.     static cilist io___155 = { 0, 6, 0, fmt_9990, 0 };
    434. 

  434.     static cilist io___158 = { 0, 6, 0, fmt_9998, 0 };
    435. 

  435.     static cilist io___166 = { 0, 6, 0, fmt_9980, 0 };
    436. 

  436.     static cilist io___167 = { 0, 6, 0, fmt_9997, 0 };
    437. 

  437.     static cilist io___168 = { 0, 6, 0, fmt_9980, 0 };
    438. 

  438.     static cilist io___169 = { 0, 6, 0, fmt_9980, 0 };
    439. 

  439.     static cilist io___170 = { 0, 6, 0, fmt_9997, 0 };
    440. 

  440.     static cilist io___171 = { 0, 6, 0, fmt_9980, 0 };
    441. 

  441.     static cilist io___173 = { 0, 6, 0, fmt_9995, 0 };
    442. 

  442.     static cilist io___174 = { 0, 6, 0, fmt_9980, 0 };
    443. 

  443.     static cilist io___175 = { 0, 6, 0, fmt_9990, 0 };
    444. 

  444.     static cilist io___176 = { 0, 6, 0, fmt_9980, 0 };
    445. 

  445.     static cilist io___177 = { 0, 6, 0, fmt_9973, 0 };
    446. 

  446.     static cilist io___178 = { 0, 6, 0, fmt_9990, 0 };
    447. 

  447.     static cilist io___179 = { 0, 6, 0, fmt_9980, 0 };
    448. 

  448.     static cilist io___180 = { 0, 6, 0, fmt_9973, 0 };
    449. 

  449.     static cilist io___181 = { 0, 6, 0, fmt_9990, 0 };
    450. 

  450.     static cilist io___182 = { 0, 6, 0, fmt_9980, 0 };
    451. 

  451.     static cilist io___183 = { 0, 6, 0, fmt_9973, 0 };
    452. 

  452.     static cilist io___184 = { 0, 6, 0, fmt_9990, 0 };
    453. 

  453.     static cilist io___185 = { 0, 6, 0, fmt_9980, 0 };
    454. 

  454.     static cilist io___186 = { 0, 6, 0, fmt_9973, 0 };
    455. 

  455.     static cilist io___187 = { 0, 6, 0, fmt_9996, 0 };
    456. 

  456.     static cilist io___190 = { 0, 6, 0, fmt_9980, 0 };
    457. 

  457.     static cilist io___191 = { 0, 6, 0, fmt_9980, 0 };
    458. 

  458.     static cilist io___192 = { 0, 6, 0, fmt_9990, 0 };
    459. 

  459.     static cilist io___193 = { 0, 6, 0, fmt_9980, 0 };
    460. 

  460.     static cilist io___194 = { 0, 6, 0, fmt_9973, 0 };
    461. 

  461.     static cilist io___195 = { 0, 6, 0, fmt_9990, 0 };
    462. 

  462.     static cilist io___197 = { 0, 6, 0, fmt_9980, 0 };
    463. 

  463.     static cilist io___198 = { 0, 6, 0, fmt_9973, 0 };
    464. 

  464.     static cilist io___199 = { 0, 6, 0, fmt_9990, 0 };
    465. 

  465.     static cilist io___200 = { 0, 6, 0, fmt_9980, 0 };
    466. 

  466.     static cilist io___201 = { 0, 6, 0, fmt_9973, 0 };
    467. 

  467.     static cilist io___202 = { 0, 6, 0, fmt_9990, 0 };
    468. 

  468.     static cilist io___203 = { 0, 6, 0, fmt_9980, 0 };
    469. 

  469.     static cilist io___204 = { 0, 6, 0, fmt_9973, 0 };
    470. 

  470.     static cilist io___205 = { 0, 6, 0, fmt_9980, 0 };
    471. 

  471.     static cilist io___206 = { 0, 6, 0, fmt_9966, 0 };
    472. 

  472.     static cilist io___207 = { 0, 6, 0, fmt_9980, 0 };
    473. 

  473.     static cilist io___210 = { 0, 6, 0, fmt_9980, 0 };
    474. 

  474.     static cilist io___213 = { 0, 6, 0, fmt_9980, 0 };
    475. 

  475.     static cilist io___214 = { 0, 6, 0, fmt_9980, 0 };
    476. 

  476.     static cilist io___215 = { 0, 6, 0, fmt_9980, 0 };
    477. 

  477.     static cilist io___216 = { 0, 6, 0, 0, 0 };
    478. 

  478.     static cilist io___217 = { 0, 6, 0, 0, 0 };
    479. 

  479.     static cilist io___218 = { 0, 6, 0, fmt_9992, 0 };
    480. 

  480.     static cilist io___219 = { 0, 6, 0, fmt_9994, 0 };
    481. 

  481.     static cilist io___221 = { 0, 6, 0, fmt_9993, 0 };
    482. 

  482. 

  483. 

  484. 

  485. #define a_ref(a_1,a_2) a[(a_2)*17424 + a_1 - 17425]
    486. 

  486. #define b_ref(a_1,a_2) b[(a_2)*17424 + a_1 - 17425]
    487. 

  487. #define c___ref(a_1,a_2) c__[(a_2)*400 + a_1 - 401]
    488. 

  488. #define d___ref(a_1,a_2) d__[(a_2)*132 + a_1 - 133]
    489. 

  489. 

  490. 

  491. /*  -- LAPACK test routine (version 3.0) --   
    492. 

  492.        Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,   
    493. 

  493.        Courant Institute, Argonne National Lab, and Rice University   
    494. 

  494.        June 30, 1999   
    495. 

    496. 

  496.     Purpose   
    497. 

  497.     =======   
    498. 

    499. 

  499.     DCHKEE tests the DOUBLE PRECISION LAPACK subroutines for the matrix   
    500. 

  500.     eigenvalue problem.  The test paths in this version are   
    501. 

    502. 

  502.     NEP (Nonsymmetric Eigenvalue Problem):   
    503. 

  503.         Test DGEHRD, DORGHR, DHSEQR, DTREVC, DHSEIN, and DORMHR   
    504. 

    505. 

  505.     SEP (Symmetric Eigenvalue Problem):   
    506. 

  506.         Test DSYTRD, DORGTR, DSTEQR, DSTERF, DSTEIN, DSTEDC,   
    507. 

  507.         and drivers DSYEV(X), DSBEV(X), DSPEV(X), DSTEV(X),   
    508. 

  508.                     DSYEVD,   DSBEVD,   DSPEVD,   DSTEVD   
    509. 

    510. 

  510.     SVD (Singular Value Decomposition):   
    511. 

  511.         Test DGEBRD, DORGBR, DBDSQR, DBDSDC   
    512. 

  512.         and the drivers DGESVD, DGESDD   
    513. 

    514. 

  514.     DEV (Nonsymmetric Eigenvalue/eigenvector Driver):   
    515. 

  515.         Test DGEEV   
    516. 

    517. 

  517.     DES (Nonsymmetric Schur form Driver):   
    518. 

  518.         Test DGEES   
    519. 

    520. 

  520.     DVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver):   
    521. 

  521.         Test DGEEVX   
    522. 

    523. 

  523.     DSX (Nonsymmetric Schur form Expert Driver):   
    524. 

  524.         Test DGEESX   
    525. 

    526. 

  526.     DGG (Generalized Nonsymmetric Eigenvalue Problem):   
    527. 

  527.         Test DGGHRD, DGGBAL, DGGBAK, DHGEQZ, and DTGEVC   
    528. 

  528.         and the driver routines DGEGS and DGEGV   
    529. 

    530. 

  530.     DGS (Generalized Nonsymmetric Schur form Driver):   
    531. 

  531.         Test DGGES   
    532. 

    533. 

  533.     DGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver):   
    534. 

  534.         Test DGGEV   
    535. 

    536. 

  536.     DGX (Generalized Nonsymmetric Schur form Expert Driver):   
    537. 

  537.         Test DGGESX   
    538. 

    539. 

  539.     DXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):   
    540. 

  540.         Test DGGEVX   
    541. 

    542. 

  542.     DSG (Symmetric Generalized Eigenvalue Problem):   
    543. 

  543.         Test DSYGST, DSYGV, DSYGVD, DSYGVX, DSPGST, DSPGV, DSPGVD,   
    544. 

  544.         DSPGVX, DSBGST, DSBGV, DSBGVD, and DSBGVX   
    545. 

    546. 

  546.     DSB (Symmetric Band Eigenvalue Problem):   
    547. 

  547.         Test DSBTRD   
    548. 

    549. 

  549.     DBB (Band Singular Value Decomposition):   
    550. 

  550.         Test DGBBRD   
    551. 

    552. 

  552.     DEC (Eigencondition estimation):   
    553. 

  553.         Test DLALN2, DLASY2, DLAEQU, DLAEXC, DTRSYL, DTREXC, DTRSNA,   
    554. 

  554.         DTRSEN, and DLAQTR   
    555. 

    556. 

  556.     DBL (Balancing a general matrix)   
    557. 

  557.         Test DGEBAL   
    558. 

    559. 

  559.     DBK (Back transformation on a balanced matrix)   
    560. 

  560.         Test DGEBAK   
    561. 

    562. 

  562.     DGL (Balancing a matrix pair)   
    563. 

  563.         Test DGGBAL   
    564. 

    565. 

  565.     DGK (Back transformation on a matrix pair)   
    566. 

  566.         Test DGGBAK   
    567. 

    568. 

  568.     GLM (Generalized Linear Regression Model):   
    569. 

  569.         Tests DGGGLM   
    570. 

    571. 

  571.     GQR (Generalized QR and RQ factorizations):   
    572. 

  572.         Tests DGGQRF and DGGRQF   
    573. 

    574. 

  574.     GSV (Generalized Singular Value Decomposition):   
    575. 

  575.         Tests DGGSVD, DGGSVP, DTGSJA, DLAGS2, DLAPLL, and DLAPMT   
    576. 

    577. 

  577.     LSE (Constrained Linear Least Squares):   
    578. 

  578.         Tests DGGLSE   
    579. 

    580. 

  580.     Each test path has a different set of inputs, but the data sets for   
    581. 

  581.     the driver routines xEV, xES, xVX, and xSX can be concatenated in a   
    582. 

  582.     single input file.  The first line of input should contain one of the   
    583. 

  583.     3-character path names in columns 1-3.  The number of remaining lines   
    584. 

  584.     depends on what is found on the first line.   
    585. 

    586. 

  586.     The number of matrix types used in testing is often controllable from   
    587. 

  587.     the input file.  The number of matrix types for each path, and the   
    588. 

  588.     test routine that describes them, is as follows:   
    589. 

    590. 

  590.     Path name(s)  Types    Test routine   
    591. 

    592. 

  592.     DHS or NEP      21     DCHKHS   
    593. 

  593.     DST or SEP      21     DCHKST (routines)   
    594. 

  594.                     18     DDRVST (drivers)   
    595. 

  595.     DBD or SVD      16     DCHKBD (routines)   
    596. 

  596.                      5     DDRVBD (drivers)   
    597. 

  597.     DEV             21     DDRVEV   
    598. 

  598.     DES             21     DDRVES   
    599. 

  599.     DVX             21     DDRVVX   
    600. 

  600.     DSX             21     DDRVSX   
    601. 

  601.     DGG             26     DCHKGG (routines)   
    602. 

  602.                     26     DDRVGG (drivers)   
    603. 

  603.     DGS             26     DDRGES   
    604. 

  604.     DGX              5     DDRGSX   
    605. 

  605.     DGV             26     DDRGEV   
    606. 

  606.     DXV              2     DDRGVX   
    607. 

  607.     DSG             21     DDRVSG   
    608. 

  608.     DSB             15     DCHKSB   
    609. 

  609.     DBB             15     DCHKBB   
    610. 

  610.     DEC              -     DCHKEC   
    611. 

  611.     DBL              -     DCHKBL   
    612. 

  612.     DBK              -     DCHKBK   
    613. 

  613.     DGL              -     DCHKGL   
    614. 

  614.     DGK              -     DCHKGK   
    615. 

  615.     GLM              8     DCKGLM   
    616. 

  616.     GQR              8     DCKGQR   
    617. 

  617.     GSV              8     DCKGSV   
    618. 

  618.     LSE              8     DCKLSE   
    619. 

    620. 

  620.    -----------------------------------------------------------------------   
    621. 

    622. 

  622.     NEP input file:   
    623. 

    624. 

  624.     line 2:  NN, INTEGER   
    625. 

  625.              Number of values of N.   
    626. 

    627. 

  627.     line 3:  NVAL, INTEGER array, dimension (NN)   
    628. 

  628.              The values for the matrix dimension N.   
    629. 

    630. 

  630.     line 4:  NPARMS, INTEGER   
    631. 

  631.              Number of values of the parameters NB, NBMIN, NX, NS, and   
    632. 

  632.              MAXB.   
    633. 

    634. 

  634.     line 5:  NBVAL, INTEGER array, dimension (NPARMS)   
    635. 

  635.              The values for the blocksize NB.   
    636. 

    637. 

  637.     line 6:  NBMIN, INTEGER array, dimension (NPARMS)   
    638. 

  638.              The values for the minimum blocksize NBMIN.   
    639. 

    640. 

  640.     line 7:  NXVAL, INTEGER array, dimension (NPARMS)   
    641. 

  641.              The values for the crossover point NX.   
    642. 

    643. 

  643.     line 8:  NSVAL, INTEGER array, dimension (NPARMS)   
    644. 

  644.              The values for the number of shifts.   
    645. 

    646. 

  646.     line 9:  MXBVAL, INTEGER array, dimension (NPARMS)   
    647. 

  647.              The values for MAXB, used in determining minimum blocksize.   
    648. 

    649. 

  649.     line 10: THRESH   
    650. 

  650.              Threshold value for the test ratios.  Information will be   
    651. 

  651.              printed about each test for which the test ratio is greater   
    652. 

  652.              than or equal to the threshold.  To have all of the test   
    653. 

  653.              ratios printed, use THRESH = 0.0 .   
    654. 

    655. 

  655.     line 11: NEWSD, INTEGER   
    656. 

  656.              A code indicating how to set the random number seed.   
    657. 

  657.              = 0:  Set the seed to a default value before each run   
    658. 

  658.              = 1:  Initialize the seed to a default value only before the   
    659. 

  659.                    first run   
    660. 

  660.              = 2:  Like 1, but use the seed values on the next line   
    661. 

    662. 

  662.     If line 11 was 2:   
    663. 

    664. 

  664.     line 12: INTEGER array, dimension (4)   
    665. 

  665.              Four integer values for the random number seed.   
    666. 

    667. 

  667.     lines 12-EOF:  The remaining lines occur in sets of 1 or 2 and allow   
    668. 

  668.              the user to specify the matrix types.  Each line contains   
    669. 

  669.              a 3-character path name in columns 1-3, and the number   
    670. 

  670.              of matrix types must be the first nonblank item in columns   
    671. 

  671.              4-80.  If the number of matrix types is at least 1 but is   
    672. 

  672.              less than the maximum number of possible types, a second   
    673. 

  673.              line will be read to get the numbers of the matrix types to   
    674. 

  674.              be used.  For example,   
    675. 

  675.     NEP 21   
    676. 

  676.              requests all of the matrix types for the nonsymmetric   
    677. 

  677.              eigenvalue problem, while   
    678. 

  678.     NEP  4   
    679. 

  679.     9 10 11 12   
    680. 

  680.              requests only matrices of type 9, 10, 11, and 12.   
    681. 

    682. 

  682.              The valid 3-character path names are 'NEP' or 'SHS' for the   
    683. 

  683.              nonsymmetric eigenvalue routines.   
    684. 

    685. 

  685.    -----------------------------------------------------------------------   
    686. 

    687. 

  687.     SEP or DSG input file:   
    688. 

    689. 

  689.     line 2:  NN, INTEGER   
    690. 

  690.              Number of values of N.   
    691. 

    692. 

  692.     line 3:  NVAL, INTEGER array, dimension (NN)   
    693. 

  693.              The values for the matrix dimension N.   
    694. 

    695. 

  695.     line 4:  NPARMS, INTEGER   
    696. 

  696.              Number of values of the parameters NB, NBMIN, and NX.   
    697. 

    698. 

  698.     line 5:  NBVAL, INTEGER array, dimension (NPARMS)   
    699. 

  699.              The values for the blocksize NB.   
    700. 

    701. 

  701.     line 6:  NBMIN, INTEGER array, dimension (NPARMS)   
    702. 

  702.              The values for the minimum blocksize NBMIN.   
    703. 

    704. 

  704.     line 7:  NXVAL, INTEGER array, dimension (NPARMS)   
    705. 

  705.              The values for the crossover point NX.   
    706. 

    707. 

  707.     line 8:  THRESH   
    708. 

  708.              Threshold value for the test ratios.  Information will be   
    709. 

  709.              printed about each test for which the test ratio is greater   
    710. 

  710.              than or equal to the threshold.   
    711. 

    712. 

  712.     line 9:  TSTCHK, LOGICAL   
    713. 

  713.              Flag indicating whether or not to test the LAPACK routines.   
    714. 

    715. 

  715.     line 10: TSTDRV, LOGICAL   
    716. 

  716.              Flag indicating whether or not to test the driver routines.   
    717. 

    718. 

  718.     line 11: TSTERR, LOGICAL   
    719. 

  719.              Flag indicating whether or not to test the error exits for   
    720. 

  720.              the LAPACK routines and driver routines.   
    721. 

    722. 

  722.     line 12: NEWSD, INTEGER   
    723. 

  723.              A code indicating how to set the random number seed.   
    724. 

  724.              = 0:  Set the seed to a default value before each run   
    725. 

  725.              = 1:  Initialize the seed to a default value only before the   
    726. 

  726.                    first run   
    727. 

  727.              = 2:  Like 1, but use the seed values on the next line   
    728. 

    729. 

  729.     If line 12 was 2:   
    730. 

    731. 

  731.     line 13: INTEGER array, dimension (4)   
    732. 

  732.              Four integer values for the random number seed.   
    733. 

    734. 

  734.     lines 13-EOF:  Lines specifying matrix types, as for NEP.   
    735. 

  735.              The 3-character path names are 'SEP' or 'SST' for the   
    736. 

  736.              symmetric eigenvalue routines and driver routines, and   
    737. 

  737.              'DSG' for the routines for the symmetric generalized   
    738. 

  738.              eigenvalue problem.   
    739. 

    740. 

  740.    -----------------------------------------------------------------------   
    741. 

    742. 

  742.     SVD input file:   
    743. 

    744. 

  744.     line 2:  NN, INTEGER   
    745. 

  745.              Number of values of M and N.   
    746. 

    747. 

  747.     line 3:  MVAL, INTEGER array, dimension (NN)   
    748. 

  748.              The values for the matrix row dimension M.   
    749. 

    750. 

  750.     line 4:  NVAL, INTEGER array, dimension (NN)   
    751. 

  751.              The values for the matrix column dimension N.   
    752. 

    753. 

  753.     line 5:  NPARMS, INTEGER   
    754. 

  754.              Number of values of the parameter NB, NBMIN, NX, and NRHS.   
    755. 

    756. 

  756.     line 6:  NBVAL, INTEGER array, dimension (NPARMS)   
    757. 

  757.              The values for the blocksize NB.   
    758. 

    759. 

  759.     line 7:  NBMIN, INTEGER array, dimension (NPARMS)   
    760. 

  760.              The values for the minimum blocksize NBMIN.   
    761. 

    762. 

  762.     line 8:  NXVAL, INTEGER array, dimension (NPARMS)   
    763. 

  763.              The values for the crossover point NX.   
    764. 

    765. 

  765.     line 9:  NSVAL, INTEGER array, dimension (NPARMS)   
    766. 

  766.              The values for the number of right hand sides NRHS.   
    767. 

    768. 

  768.     line 10: THRESH   
    769. 

  769.              Threshold value for the test ratios.  Information will be   
    770. 

  770.              printed about each test for which the test ratio is greater   
    771. 

  771.              than or equal to the threshold.   
    772. 

    773. 

  773.     line 11: TSTCHK, LOGICAL   
    774. 

  774.              Flag indicating whether or not to test the LAPACK routines.   
    775. 

    776. 

  776.     line 12: TSTDRV, LOGICAL   
    777. 

  777.              Flag indicating whether or not to test the driver routines.   
    778. 

    779. 

  779.     line 13: TSTERR, LOGICAL   
    780. 

  780.              Flag indicating whether or not to test the error exits for   
    781. 

  781.              the LAPACK routines and driver routines.   
    782. 

    783. 

  783.     line 14: NEWSD, INTEGER   
    784. 

  784.              A code indicating how to set the random number seed.   
    785. 

  785.              = 0:  Set the seed to a default value before each run   
    786. 

  786.              = 1:  Initialize the seed to a default value only before the   
    787. 

  787.                    first run   
    788. 

  788.              = 2:  Like 1, but use the seed values on the next line   
    789. 

    790. 

  790.     If line 14 was 2:   
    791. 

    792. 

  792.     line 15: INTEGER array, dimension (4)   
    793. 

  793.              Four integer values for the random number seed.   
    794. 

    795. 

  795.     lines 15-EOF:  Lines specifying matrix types, as for NEP.   
    796. 

  796.              The 3-character path names are 'SVD' or 'SBD' for both the   
    797. 

  797.              SVD routines and the SVD driver routines.   
    798. 

    799. 

  799.    -----------------------------------------------------------------------   
    800. 

    801. 

  801.     DEV and DES data files:   
    802. 

    803. 

  803.     line 1:  'DEV' or 'DES' in columns 1 to 3.   
    804. 

    805. 

  805.     line 2:  NSIZES, INTEGER   
    806. 

  806.              Number of sizes of matrices to use. Should be at least 0   
    807. 

  807.              and at most 20. If NSIZES = 0, no testing is done   
    808. 

  808.              (although the remaining  3 lines are still read).   
    809. 

    810. 

  810.     line 3:  NN, INTEGER array, dimension(NSIZES)   
    811. 

  811.              Dimensions of matrices to be tested.   
    812. 

    813. 

  813.     line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs   
    814. 

  814.              These integer parameters determine how blocking is done   
    815. 

  815.              (see ILAENV for details)   
    816. 

  816.              NB     : block size   
    817. 

  817.              NBMIN  : minimum block size   
    818. 

  818.              NX     : minimum dimension for blocking   
    819. 

  819.              NS     : number of shifts in xHSEQR   
    820. 

  820.              NBCOL  : minimum column dimension for blocking   
    821. 

    822. 

  822.     line 5:  THRESH, REAL   
    823. 

  823.              The test threshold against which computed residuals are   
    824. 

  824.              compared. Should generally be in the range from 10. to 20.   
    825. 

  825.              If it is 0., all test case data will be printed.   
    826. 

    827. 

  827.     line 6:  TSTERR, LOGICAL   
    828. 

  828.              Flag indicating whether or not to test the error exits.   
    829. 

    830. 

  830.     line 7:  NEWSD, INTEGER   
    831. 

  831.              A code indicating how to set the random number seed.   
    832. 

  832.              = 0:  Set the seed to a default value before each run   
    833. 

  833.              = 1:  Initialize the seed to a default value only before the   
    834. 

  834.                    first run   
    835. 

  835.              = 2:  Like 1, but use the seed values on the next line   
    836. 

    837. 

  837.     If line 7 was 2:   
    838. 

    839. 

  839.     line 8:  INTEGER array, dimension (4)   
    840. 

  840.              Four integer values for the random number seed.   
    841. 

    842. 

  842.     lines 9 and following:  Lines specifying matrix types, as for NEP.   
    843. 

  843.              The 3-character path name is 'DEV' to test SGEEV, or   
    844. 

  844.              'DES' to test SGEES.   
    845. 

    846. 

  846.    -----------------------------------------------------------------------   
    847. 

    848. 

  848.     The DVX data has two parts. The first part is identical to DEV,   
    849. 

  849.     and the second part consists of test matrices with precomputed   
    850. 

  850.     solutions.   
    851. 

    852. 

  852.     line 1:  'DVX' in columns 1-3.   
    853. 

    854. 

  854.     line 2:  NSIZES, INTEGER   
    855. 

  855.              If NSIZES = 0, no testing of randomly generated examples   
    856. 

  856.              is done, but any precomputed examples are tested.   
    857. 

    858. 

  858.     line 3:  NN, INTEGER array, dimension(NSIZES)   
    859. 

    860. 

  860.     line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs   
    861. 

    862. 

  862.     line 5:  THRESH, REAL   
    863. 

    864. 

  864.     line 6:  TSTERR, LOGICAL   
    865. 

    866. 

  866.     line 7:  NEWSD, INTEGER   
    867. 

    868. 

  868.     If line 7 was 2:   
    869. 

    870. 

  870.     line 8:  INTEGER array, dimension (4)   
    871. 

    872. 

  872.     lines 9 and following: The first line contains 'DVX' in columns 1-3   
    873. 

  873.              followed by the number of matrix types, possibly with   
    874. 

  874.              a second line to specify certain matrix types.   
    875. 

  875.              If the number of matrix types = 0, no testing of randomly   
    876. 

  876.              generated examples is done, but any precomputed examples   
    877. 

  877.              are tested.   
    878. 

    879. 

  879.     remaining lines : Each matrix is stored on 1+2*N lines, where N is   
    880. 

  880.              its dimension. The first line contains the dimension (a   
    881. 

  881.              single integer). The next N lines contain the matrix, one   
    882. 

  882.              row per line. The last N lines correspond to each   
    883. 

  883.              eigenvalue. Each of these last N lines contains 4 real   
    884. 

  884.              values: the real part of the eigenvalue, the imaginary   
    885. 

  885.              part of the eigenvalue, the reciprocal condition number of   
    886. 

  886.              the eigenvalues, and the reciprocal condition number of the   
    887. 

  887.              eigenvector.  The end of data is indicated by dimension N=0.   
    888. 

  888.              Even if no data is to be tested, there must be at least one   
    889. 

  889.              line containing N=0.   
    890. 

    891. 

  891.    -----------------------------------------------------------------------   
    892. 

    893. 

  893.     The DSX data is like DVX. The first part is identical to DEV, and the   
    894. 

  894.     second part consists of test matrices with precomputed solutions.   
    895. 

    896. 

  896.     line 1:  'DSX' in columns 1-3.   
    897. 

    898. 

  898.     line 2:  NSIZES, INTEGER   
    899. 

  899.              If NSIZES = 0, no testing of randomly generated examples   
    900. 

  900.              is done, but any precomputed examples are tested.   
    901. 

    902. 

  902.     line 3:  NN, INTEGER array, dimension(NSIZES)   
    903. 

    904. 

  904.     line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs   
    905. 

    906. 

  906.     line 5:  THRESH, REAL   
    907. 

    908. 

  908.     line 6:  TSTERR, LOGICAL   
    909. 

    910. 

  910.     line 7:  NEWSD, INTEGER   
    911. 

    912. 

  912.     If line 7 was 2:   
    913. 

    914. 

  914.     line 8:  INTEGER array, dimension (4)   
    915. 

    916. 

  916.     lines 9 and following: The first line contains 'DSX' in columns 1-3   
    917. 

  917.              followed by the number of matrix types, possibly with   
    918. 

  918.              a second line to specify certain matrix types.   
    919. 

  919.              If the number of matrix types = 0, no testing of randomly   
    920. 

  920.              generated examples is done, but any precomputed examples   
    921. 

  921.              are tested.   
    922. 

    923. 

  923.     remaining lines : Each matrix is stored on 3+N lines, where N is its   
    924. 

  924.              dimension. The first line contains the dimension N and the   
    925. 

  925.              dimension M of an invariant subspace. The second line   
    926. 

  926.              contains M integers, identifying the eigenvalues in the   
    927. 

  927.              invariant subspace (by their position in a list of   
    928. 

  928.              eigenvalues ordered by increasing real part). The next N   
    929. 

  929.              lines contain the matrix. The last line contains the   
    930. 

  930.              reciprocal condition number for the average of the selected   
    931. 

  931.              eigenvalues, and the reciprocal condition number for the   
    932. 

  932.              corresponding right invariant subspace. The end of data is   
    933. 

  933.              indicated by a line containing N=0 and M=0. Even if no data   
    934. 

  934.              is to be tested, there must be at least one line containing   
    935. 

  935.              N=0 and M=0.   
    936. 

    937. 

  937.    -----------------------------------------------------------------------   
    938. 

    939. 

  939.     DGG input file:   
    940. 

    941. 

  941.     line 2:  NN, INTEGER   
    942. 

  942.              Number of values of N.   
    943. 

    944. 

  944.     line 3:  NVAL, INTEGER array, dimension (NN)   
    945. 

  945.              The values for the matrix dimension N.   
    946. 

    947. 

  947.     line 4:  NPARMS, INTEGER   
    948. 

  948.              Number of values of the parameters NB, NBMIN, NS, MAXB, and   
    949. 

  949.              NBCOL.   
    950. 

    951. 

  951.     line 5:  NBVAL, INTEGER array, dimension (NPARMS)   
    952. 

  952.              The values for the blocksize NB.   
    953. 

    954. 

  954.     line 6:  NBMIN, INTEGER array, dimension (NPARMS)   
    955. 

  955.              The values for NBMIN, the minimum row dimension for blocks.   
    956. 

    957. 

  957.     line 7:  NSVAL, INTEGER array, dimension (NPARMS)   
    958. 

  958.              The values for the number of shifts.   
    959. 

    960. 

  960.     line 8:  MXBVAL, INTEGER array, dimension (NPARMS)   
    961. 

  961.              The values for MAXB, used in determining minimum blocksize.   
    962. 

    963. 

  963.     line 9:  NBCOL, INTEGER array, dimension (NPARMS)   
    964. 

  964.              The values for NBCOL, the minimum column dimension for   
    965. 

  965.              blocks.   
    966. 

    967. 

  967.     line 10: THRESH   
    968. 

  968.              Threshold value for the test ratios.  Information will be   
    969. 

  969.              printed about each test for which the test ratio is greater   
    970. 

  970.              than or equal to the threshold.   
    971. 

    972. 

  972.     line 11: TSTCHK, LOGICAL   
    973. 

  973.              Flag indicating whether or not to test the LAPACK routines.   
    974. 

    975. 

  975.     line 12: TSTDRV, LOGICAL   
    976. 

  976.              Flag indicating whether or not to test the driver routines.   
    977. 

    978. 

  978.     line 13: TSTERR, LOGICAL   
    979. 

  979.              Flag indicating whether or not to test the error exits for   
    980. 

  980.              the LAPACK routines and driver routines.   
    981. 

    982. 

  982.     line 14: NEWSD, INTEGER   
    983. 

  983.              A code indicating how to set the random number seed.   
    984. 

  984.              = 0:  Set the seed to a default value before each run   
    985. 

  985.              = 1:  Initialize the seed to a default value only before the   
    986. 

  986.                    first run   
    987. 

  987.              = 2:  Like 1, but use the seed values on the next line   
    988. 

    989. 

  989.     If line 14 was 2:   
    990. 

    991. 

  991.     line 15: INTEGER array, dimension (4)   
    992. 

  992.              Four integer values for the random number seed.   
    993. 

    994. 

  994.     lines 15-EOF:  Lines specifying matrix types, as for NEP.   
    995. 

  995.              The 3-character path name is 'DGG' for the generalized   
    996. 

  996.              eigenvalue problem routines and driver routines.   
    997. 

    998. 

  998.    -----------------------------------------------------------------------   
    999. 

    1000. 

  1000.     DGS and DGV input files:   
    1001. 

    1002. 

  1002.     line 1:  'DGS' or 'DGV' in columns 1 to 3.   
    1003. 

    1004. 

  1004.     line 2:  NN, INTEGER   
    1005. 

  1005.              Number of values of N.   
    1006. 

    1007. 

  1007.     line 3:  NVAL, INTEGER array, dimension(NN)   
    1008. 

  1008.              Dimensions of matrices to be tested.   
    1009. 

    1010. 

  1010.     line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs   
    1011. 

  1011.              These integer parameters determine how blocking is done   
    1012. 

  1012.              (see ILAENV for details)   
    1013. 

  1013.              NB     : block size   
    1014. 

  1014.              NBMIN  : minimum block size   
    1015. 

  1015.              NX     : minimum dimension for blocking   
    1016. 

  1016.              NS     : number of shifts in xHGEQR   
    1017. 

  1017.              NBCOL  : minimum column dimension for blocking   
    1018. 

    1019. 

  1019.     line 5:  THRESH, REAL   
    1020. 

  1020.              The test threshold against which computed residuals are   
    1021. 

  1021.              compared. Should generally be in the range from 10. to 20.   
    1022. 

  1022.              If it is 0., all test case data will be printed.   
    1023. 

    1024. 

  1024.     line 6:  TSTERR, LOGICAL   
    1025. 

  1025.              Flag indicating whether or not to test the error exits.   
    1026. 

    1027. 

  1027.     line 7:  NEWSD, INTEGER   
    1028. 

  1028.              A code indicating how to set the random number seed.   
    1029. 

  1029.              = 0:  Set the seed to a default value before each run   
    1030. 

  1030.              = 1:  Initialize the seed to a default value only before the   
    1031. 

  1031.                    first run   
    1032. 

  1032.              = 2:  Like 1, but use the seed values on the next line   
    1033. 

    1034. 

  1034.     If line 17 was 2:   
    1035. 

    1036. 

  1036.     line 7:  INTEGER array, dimension (4)   
    1037. 

  1037.              Four integer values for the random number seed.   
    1038. 

    1039. 

  1039.     lines 7-EOF:  Lines specifying matrix types, as for NEP.   
    1040. 

  1040.              The 3-character path name is 'DGS' for the generalized   
    1041. 

  1041.              eigenvalue problem routines and driver routines.   
    1042. 

    1043. 

  1043.    -----------------------------------------------------------------------   
    1044. 

    1045. 

  1045.     DXV input files:   
    1046. 

    1047. 

  1047.     line 1:  'DXV' in columns 1 to 3.   
    1048. 

    1049. 

  1049.     line 2:  N, INTEGER   
    1050. 

  1050.              Value of N.   
    1051. 

    1052. 

  1052.     line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs   
    1053. 

  1053.              These integer parameters determine how blocking is done   
    1054. 

  1054.              (see ILAENV for details)   
    1055. 

  1055.              NB     : block size   
    1056. 

  1056.              NBMIN  : minimum block size   
    1057. 

  1057.              NX     : minimum dimension for blocking   
    1058. 

  1058.              NS     : number of shifts in xHGEQR   
    1059. 

  1059.              NBCOL  : minimum column dimension for blocking   
    1060. 

    1061. 

  1061.     line 4:  THRESH, REAL   
    1062. 

  1062.              The test threshold against which computed residuals are   
    1063. 

  1063.              compared. Should generally be in the range from 10. to 20.   
    1064. 

  1064.              Information will be printed about each test for which the   
    1065. 

  1065.              test ratio is greater than or equal to the threshold.   
    1066. 

    1067. 

  1067.     line 5:  TSTERR, LOGICAL   
    1068. 

  1068.              Flag indicating whether or not to test the error exits for   
    1069. 

  1069.              the LAPACK routines and driver routines.   
    1070. 

    1071. 

  1071.     line 6:  NEWSD, INTEGER   
    1072. 

  1072.              A code indicating how to set the random number seed.   
    1073. 

  1073.              = 0:  Set the seed to a default value before each run   
    1074. 

  1074.              = 1:  Initialize the seed to a default value only before the   
    1075. 

  1075.                    first run   
    1076. 

  1076.              = 2:  Like 1, but use the seed values on the next line   
    1077. 

    1078. 

  1078.     If line 6 was 2:   
    1079. 

    1080. 

  1080.     line 7: INTEGER array, dimension (4)   
    1081. 

  1081.              Four integer values for the random number seed.   
    1082. 

    1083. 

  1083.     If line 2 was 0:   
    1084. 

    1085. 

  1085.     line 7-EOF: Precomputed examples are tested.   
    1086. 

    1087. 

  1087.     remaining lines : Each example is stored on 3+2*N lines, where N is   
    1088. 

  1088.              its dimension. The first line contains the dimension (a   
    1089. 

  1089.              single integer). The next N lines contain the matrix A, one   
    1090. 

  1090.              row per line. The next N lines contain the matrix B.  The   
    1091. 

  1091.              next line contains the reciprocals of the eigenvalue   
    1092. 

  1092.              condition numbers.  The last line contains the reciprocals of   
    1093. 

  1093.              the eigenvector condition numbers.  The end of data is   
    1094. 

  1094.              indicated by dimension N=0.  Even if no data is to be tested,   
    1095. 

  1095.              there must be at least one line containing N=0.   
    1096. 

    1097. 

  1097.    -----------------------------------------------------------------------   
    1098. 

    1099. 

  1099.     DGX input files:   
    1100. 

    1101. 

  1101.     line 1:  'DGX' in columns 1 to 3.   
    1102. 

    1103. 

  1103.     line 2:  N, INTEGER   
    1104. 

  1104.              Value of N.   
    1105. 

    1106. 

  1106.     line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs   
    1107. 

  1107.              These integer parameters determine how blocking is done   
    1108. 

  1108.              (see ILAENV for details)   
    1109. 

  1109.              NB     : block size   
    1110. 

  1110.              NBMIN  : minimum block size   
    1111. 

  1111.              NX     : minimum dimension for blocking   
    1112. 

  1112.              NS     : number of shifts in xHGEQR   
    1113. 

  1113.              NBCOL  : minimum column dimension for blocking   
    1114. 

    1115. 

  1115.     line 4:  THRESH, REAL   
    1116. 

  1116.              The test threshold against which computed residuals are   
    1117. 

  1117.              compared. Should generally be in the range from 10. to 20.   
    1118. 

  1118.              Information will be printed about each test for which the   
    1119. 

  1119.              test ratio is greater than or equal to the threshold.   
    1120. 

    1121. 

  1121.     line 5:  TSTERR, LOGICAL   
    1122. 

  1122.              Flag indicating whether or not to test the error exits for   
    1123. 

  1123.              the LAPACK routines and driver routines.   
    1124. 

    1125. 

  1125.     line 6:  NEWSD, INTEGER   
    1126. 

  1126.              A code indicating how to set the random number seed.   
    1127. 

  1127.              = 0:  Set the seed to a default value before each run   
    1128. 

  1128.              = 1:  Initialize the seed to a default value only before the   
    1129. 

  1129.                    first run   
    1130. 

  1130.              = 2:  Like 1, but use the seed values on the ne…
    1131.

Large files files are truncated, but you can click here to view the full file