|
LAPACK 3.3.0
|
|
LAPACK 3.3.0
|
00001 PROGRAM ZCHKEE 00002 * 00003 * -- LAPACK test routine (version 3.3.0) -- 00004 * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. 00005 * February 2007 00006 * 00007 * Purpose 00008 * ======= 00009 * 00010 * ZCHKEE tests the COMPLEX*16 LAPACK subroutines for the matrix 00011 * eigenvalue problem. The test paths in this version are 00012 * 00013 * NEP (Nonsymmetric Eigenvalue Problem): 00014 * Test ZGEHRD, ZUNGHR, ZHSEQR, ZTREVC, ZHSEIN, and ZUNMHR 00015 * 00016 * SEP (Hermitian Eigenvalue Problem): 00017 * Test ZHETRD, ZUNGTR, ZSTEQR, ZSTERF, ZSTEIN, ZSTEDC, 00018 * and drivers ZHEEV(X), ZHBEV(X), ZHPEV(X), 00019 * ZHEEVD, ZHBEVD, ZHPEVD 00020 * 00021 * SVD (Singular Value Decomposition): 00022 * Test ZGEBRD, ZUNGBR, and ZBDSQR 00023 * and the drivers ZGESVD, ZGESDD 00024 * 00025 * ZEV (Nonsymmetric Eigenvalue/eigenvector Driver): 00026 * Test ZGEEV 00027 * 00028 * ZES (Nonsymmetric Schur form Driver): 00029 * Test ZGEES 00030 * 00031 * ZVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver): 00032 * Test ZGEEVX 00033 * 00034 * ZSX (Nonsymmetric Schur form Expert Driver): 00035 * Test ZGEESX 00036 * 00037 * ZGG (Generalized Nonsymmetric Eigenvalue Problem): 00038 * Test ZGGHRD, ZGGBAL, ZGGBAK, ZHGEQZ, and ZTGEVC 00039 * and the driver routines ZGEGS and ZGEGV 00040 * 00041 * ZGS (Generalized Nonsymmetric Schur form Driver): 00042 * Test ZGGES 00043 * 00044 * ZGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver): 00045 * Test ZGGEV 00046 * 00047 * ZGX (Generalized Nonsymmetric Schur form Expert Driver): 00048 * Test ZGGESX 00049 * 00050 * ZXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver): 00051 * Test ZGGEVX 00052 * 00053 * ZSG (Hermitian Generalized Eigenvalue Problem): 00054 * Test ZHEGST, ZHEGV, ZHEGVD, ZHEGVX, ZHPGST, ZHPGV, ZHPGVD, 00055 * ZHPGVX, ZHBGST, ZHBGV, ZHBGVD, and ZHBGVX 00056 * 00057 * ZHB (Hermitian Band Eigenvalue Problem): 00058 * Test ZHBTRD 00059 * 00060 * ZBB (Band Singular Value Decomposition): 00061 * Test ZGBBRD 00062 * 00063 * ZEC (Eigencondition estimation): 00064 * Test ZTRSYL, ZTREXC, ZTRSNA, and ZTRSEN 00065 * 00066 * ZBL (Balancing a general matrix) 00067 * Test ZGEBAL 00068 * 00069 * ZBK (Back transformation on a balanced matrix) 00070 * Test ZGEBAK 00071 * 00072 * ZGL (Balancing a matrix pair) 00073 * Test ZGGBAL 00074 * 00075 * ZGK (Back transformation on a matrix pair) 00076 * Test ZGGBAK 00077 * 00078 * GLM (Generalized Linear Regression Model): 00079 * Tests ZGGGLM 00080 * 00081 * GQR (Generalized QR and RQ factorizations): 00082 * Tests ZGGQRF and ZGGRQF 00083 * 00084 * GSV (Generalized Singular Value Decomposition): 00085 * Tests ZGGSVD, ZGGSVP, ZTGSJA, ZLAGS2, ZLAPLL, and ZLAPMT 00086 * 00087 * CSD (CS decomposition): 00088 * Tests ZUNCSD 00089 * 00090 * LSE (Constrained Linear Least Squares): 00091 * Tests ZGGLSE 00092 * 00093 * Each test path has a different set of inputs, but the data sets for 00094 * the driver routines xEV, xES, xVX, and xSX can be concatenated in a 00095 * single input file. The first line of input should contain one of the 00096 * 3-character path names in columns 1-3. The number of remaining lines 00097 * depends on what is found on the first line. 00098 * 00099 * The number of matrix types used in testing is often controllable from 00100 * the input file. The number of matrix types for each path, and the 00101 * test routine that describes them, is as follows: 00102 * 00103 * Path name(s) Types Test routine 00104 * 00105 * ZHS or NEP 21 ZCHKHS 00106 * ZST or SEP 21 ZCHKST (routines) 00107 * 18 ZDRVST (drivers) 00108 * ZBD or SVD 16 ZCHKBD (routines) 00109 * 5 ZDRVBD (drivers) 00110 * ZEV 21 ZDRVEV 00111 * ZES 21 ZDRVES 00112 * ZVX 21 ZDRVVX 00113 * ZSX 21 ZDRVSX 00114 * ZGG 26 ZCHKGG (routines) 00115 * 26 ZDRVGG (drivers) 00116 * ZGS 26 ZDRGES 00117 * ZGX 5 ZDRGSX 00118 * ZGV 26 ZDRGEV 00119 * ZXV 2 ZDRGVX 00120 * ZSG 21 ZDRVSG 00121 * ZHB 15 ZCHKHB 00122 * ZBB 15 ZCHKBB 00123 * ZEC - ZCHKEC 00124 * ZBL - ZCHKBL 00125 * ZBK - ZCHKBK 00126 * ZGL - ZCHKGL 00127 * ZGK - ZCHKGK 00128 * GLM 8 ZCKGLM 00129 * GQR 8 ZCKGQR 00130 * GSV 8 ZCKGSV 00131 * CSD 3 ZCKCSD 00132 * LSE 8 ZCKLSE 00133 * 00134 *----------------------------------------------------------------------- 00135 * 00136 * NEP input file: 00137 * 00138 * line 2: NN, INTEGER 00139 * Number of values of N. 00140 * 00141 * line 3: NVAL, INTEGER array, dimension (NN) 00142 * The values for the matrix dimension N. 00143 * 00144 * line 4: NPARMS, INTEGER 00145 * Number of values of the parameters NB, NBMIN, NX, NS, and 00146 * MAXB. 00147 * 00148 * line 5: NBVAL, INTEGER array, dimension (NPARMS) 00149 * The values for the blocksize NB. 00150 * 00151 * line 6: NBMIN, INTEGER array, dimension (NPARMS) 00152 * The values for the minimum blocksize NBMIN. 00153 * 00154 * line 7: NXVAL, INTEGER array, dimension (NPARMS) 00155 * The values for the crossover point NX. 00156 * 00157 * line 8: INMIN, INTEGER array, dimension (NPARMS) 00158 * LAHQR vs TTQRE crossover point, >= 11 00159 * 00160 * line 9: INWIN, INTEGER array, dimension (NPARMS) 00161 * recommended deflation window size 00162 * 00163 * line 10: INIBL, INTEGER array, dimension (NPARMS) 00164 * nibble crossover point 00165 * 00166 * line 11: ISHFTS, INTEGER array, dimension (NPARMS) 00167 * number of simultaneous shifts) 00168 * 00169 * line 12: IACC22, INTEGER array, dimension (NPARMS) 00170 * select structured matrix multiply: 0, 1 or 2) 00171 * 00172 * line 13: THRESH 00173 * Threshold value for the test ratios. Information will be 00174 * printed about each test for which the test ratio is greater 00175 * than or equal to the threshold. To have all of the test 00176 * ratios printed, use THRESH = 0.0 . 00177 * 00178 * line 14: NEWSD, INTEGER 00179 * A code indicating how to set the random number seed. 00180 * = 0: Set the seed to a default value before each run 00181 * = 1: Initialize the seed to a default value only before the 00182 * first run 00183 * = 2: Like 1, but use the seed values on the next line 00184 * 00185 * If line 14 was 2: 00186 * 00187 * line 15: INTEGER array, dimension (4) 00188 * Four integer values for the random number seed. 00189 * 00190 * lines 15-EOF: The remaining lines occur in sets of 1 or 2 and allow 00191 * the user to specify the matrix types. Each line contains 00192 * a 3-character path name in columns 1-3, and the number 00193 * of matrix types must be the first nonblank item in columns 00194 * 4-80. If the number of matrix types is at least 1 but is 00195 * less than the maximum number of possible types, a second 00196 * line will be read to get the numbers of the matrix types to 00197 * be used. For example, 00198 * NEP 21 00199 * requests all of the matrix types for the nonsymmetric 00200 * eigenvalue problem, while 00201 * NEP 4 00202 * 9 10 11 12 00203 * requests only matrices of type 9, 10, 11, and 12. 00204 * 00205 * The valid 3-character path names are 'NEP' or 'ZHS' for the 00206 * nonsymmetric eigenvalue routines. 00207 * 00208 *----------------------------------------------------------------------- 00209 * 00210 * SEP or ZSG input file: 00211 * 00212 * line 2: NN, INTEGER 00213 * Number of values of N. 00214 * 00215 * line 3: NVAL, INTEGER array, dimension (NN) 00216 * The values for the matrix dimension N. 00217 * 00218 * line 4: NPARMS, INTEGER 00219 * Number of values of the parameters NB, NBMIN, and NX. 00220 * 00221 * line 5: NBVAL, INTEGER array, dimension (NPARMS) 00222 * The values for the blocksize NB. 00223 * 00224 * line 6: NBMIN, INTEGER array, dimension (NPARMS) 00225 * The values for the minimum blocksize NBMIN. 00226 * 00227 * line 7: NXVAL, INTEGER array, dimension (NPARMS) 00228 * The values for the crossover point NX. 00229 * 00230 * line 8: THRESH 00231 * Threshold value for the test ratios. Information will be 00232 * printed about each test for which the test ratio is greater 00233 * than or equal to the threshold. 00234 * 00235 * line 9: TSTCHK, LOGICAL 00236 * Flag indicating whether or not to test the LAPACK routines. 00237 * 00238 * line 10: TSTDRV, LOGICAL 00239 * Flag indicating whether or not to test the driver routines. 00240 * 00241 * line 11: TSTERR, LOGICAL 00242 * Flag indicating whether or not to test the error exits for 00243 * the LAPACK routines and driver routines. 00244 * 00245 * line 12: NEWSD, INTEGER 00246 * A code indicating how to set the random number seed. 00247 * = 0: Set the seed to a default value before each run 00248 * = 1: Initialize the seed to a default value only before the 00249 * first run 00250 * = 2: Like 1, but use the seed values on the next line 00251 * 00252 * If line 12 was 2: 00253 * 00254 * line 13: INTEGER array, dimension (4) 00255 * Four integer values for the random number seed. 00256 * 00257 * lines 13-EOF: Lines specifying matrix types, as for NEP. 00258 * The valid 3-character path names are 'SEP' or 'ZST' for the 00259 * Hermitian eigenvalue routines and driver routines, and 00260 * 'ZSG' for the routines for the Hermitian generalized 00261 * eigenvalue problem. 00262 * 00263 *----------------------------------------------------------------------- 00264 * 00265 * SVD input file: 00266 * 00267 * line 2: NN, INTEGER 00268 * Number of values of M and N. 00269 * 00270 * line 3: MVAL, INTEGER array, dimension (NN) 00271 * The values for the matrix row dimension M. 00272 * 00273 * line 4: NVAL, INTEGER array, dimension (NN) 00274 * The values for the matrix column dimension N. 00275 * 00276 * line 5: NPARMS, INTEGER 00277 * Number of values of the parameter NB, NBMIN, NX, and NRHS. 00278 * 00279 * line 6: NBVAL, INTEGER array, dimension (NPARMS) 00280 * The values for the blocksize NB. 00281 * 00282 * line 7: NBMIN, INTEGER array, dimension (NPARMS) 00283 * The values for the minimum blocksize NBMIN. 00284 * 00285 * line 8: NXVAL, INTEGER array, dimension (NPARMS) 00286 * The values for the crossover point NX. 00287 * 00288 * line 9: NSVAL, INTEGER array, dimension (NPARMS) 00289 * The values for the number of right hand sides NRHS. 00290 * 00291 * line 10: THRESH 00292 * Threshold value for the test ratios. Information will be 00293 * printed about each test for which the test ratio is greater 00294 * than or equal to the threshold. 00295 * 00296 * line 11: TSTCHK, LOGICAL 00297 * Flag indicating whether or not to test the LAPACK routines. 00298 * 00299 * line 12: TSTDRV, LOGICAL 00300 * Flag indicating whether or not to test the driver routines. 00301 * 00302 * line 13: TSTERR, LOGICAL 00303 * Flag indicating whether or not to test the error exits for 00304 * the LAPACK routines and driver routines. 00305 * 00306 * line 14: NEWSD, INTEGER 00307 * A code indicating how to set the random number seed. 00308 * = 0: Set the seed to a default value before each run 00309 * = 1: Initialize the seed to a default value only before the 00310 * first run 00311 * = 2: Like 1, but use the seed values on the next line 00312 * 00313 * If line 14 was 2: 00314 * 00315 * line 15: INTEGER array, dimension (4) 00316 * Four integer values for the random number seed. 00317 * 00318 * lines 15-EOF: Lines specifying matrix types, as for NEP. 00319 * The 3-character path names are 'SVD' or 'ZBD' for both the 00320 * SVD routines and the SVD driver routines. 00321 * 00322 *----------------------------------------------------------------------- 00323 * 00324 * ZEV and ZES data files: 00325 * 00326 * line 1: 'ZEV' or 'ZES' in columns 1 to 3. 00327 * 00328 * line 2: NSIZES, INTEGER 00329 * Number of sizes of matrices to use. Should be at least 0 00330 * and at most 20. If NSIZES = 0, no testing is done 00331 * (although the remaining 3 lines are still read). 00332 * 00333 * line 3: NN, INTEGER array, dimension(NSIZES) 00334 * Dimensions of matrices to be tested. 00335 * 00336 * line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 00337 * These integer parameters determine how blocking is done 00338 * (see ILAENV for details) 00339 * NB : block size 00340 * NBMIN : minimum block size 00341 * NX : minimum dimension for blocking 00342 * NS : number of shifts in xHSEQR 00343 * NBCOL : minimum column dimension for blocking 00344 * 00345 * line 5: THRESH, REAL 00346 * The test threshold against which computed residuals are 00347 * compared. Should generally be in the range from 10. to 20. 00348 * If it is 0., all test case data will be printed. 00349 * 00350 * line 6: NEWSD, INTEGER 00351 * A code indicating how to set the random number seed. 00352 * = 0: Set the seed to a default value before each run 00353 * = 1: Initialize the seed to a default value only before the 00354 * first run 00355 * = 2: Like 1, but use the seed values on the next line 00356 * 00357 * If line 6 was 2: 00358 * 00359 * line 7: INTEGER array, dimension (4) 00360 * Four integer values for the random number seed. 00361 * 00362 * lines 8 and following: Lines specifying matrix types, as for NEP. 00363 * The 3-character path name is 'ZEV' to test CGEEV, or 00364 * 'ZES' to test CGEES. 00365 * 00366 *----------------------------------------------------------------------- 00367 * 00368 * The ZVX data has two parts. The first part is identical to ZEV, 00369 * and the second part consists of test matrices with precomputed 00370 * solutions. 00371 * 00372 * line 1: 'ZVX' in columns 1-3. 00373 * 00374 * line 2: NSIZES, INTEGER 00375 * If NSIZES = 0, no testing of randomly generated examples 00376 * is done, but any precomputed examples are tested. 00377 * 00378 * line 3: NN, INTEGER array, dimension(NSIZES) 00379 * 00380 * line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 00381 * 00382 * line 5: THRESH, REAL 00383 * 00384 * line 6: NEWSD, INTEGER 00385 * 00386 * If line 6 was 2: 00387 * 00388 * line 7: INTEGER array, dimension (4) 00389 * 00390 * lines 8 and following: The first line contains 'ZVX' in columns 1-3 00391 * followed by the number of matrix types, possibly with 00392 * a second line to specify certain matrix types. 00393 * If the number of matrix types = 0, no testing of randomly 00394 * generated examples is done, but any precomputed examples 00395 * are tested. 00396 * 00397 * remaining lines : Each matrix is stored on 1+N+N**2 lines, where N is 00398 * its dimension. The first line contains the dimension N and 00399 * ISRT (two integers). ISRT indicates whether the last N lines 00400 * are sorted by increasing real part of the eigenvalue 00401 * (ISRT=0) or by increasing imaginary part (ISRT=1). The next 00402 * N**2 lines contain the matrix rowwise, one entry per line. 00403 * The last N lines correspond to each eigenvalue. Each of 00404 * these last N lines contains 4 real values: the real part of 00405 * the eigenvalues, the imaginary part of the eigenvalue, the 00406 * reciprocal condition number of the eigenvalues, and the 00407 * reciprocal condition number of the vector eigenvector. The 00408 * end of data is indicated by dimension N=0. Even if no data 00409 * is to be tested, there must be at least one line containing 00410 * N=0. 00411 * 00412 *----------------------------------------------------------------------- 00413 * 00414 * The ZSX data is like ZVX. The first part is identical to ZEV, and the 00415 * second part consists of test matrices with precomputed solutions. 00416 * 00417 * line 1: 'ZSX' in columns 1-3. 00418 * 00419 * line 2: NSIZES, INTEGER 00420 * If NSIZES = 0, no testing of randomly generated examples 00421 * is done, but any precomputed examples are tested. 00422 * 00423 * line 3: NN, INTEGER array, dimension(NSIZES) 00424 * 00425 * line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 00426 * 00427 * line 5: THRESH, REAL 00428 * 00429 * line 6: NEWSD, INTEGER 00430 * 00431 * If line 6 was 2: 00432 * 00433 * line 7: INTEGER array, dimension (4) 00434 * 00435 * lines 8 and following: The first line contains 'ZSX' in columns 1-3 00436 * followed by the number of matrix types, possibly with 00437 * a second line to specify certain matrix types. 00438 * If the number of matrix types = 0, no testing of randomly 00439 * generated examples is done, but any precomputed examples 00440 * are tested. 00441 * 00442 * remaining lines : Each matrix is stored on 3+N**2 lines, where N is 00443 * its dimension. The first line contains the dimension N, the 00444 * dimension M of an invariant subspace, and ISRT. The second 00445 * line contains M integers, identifying the eigenvalues in the 00446 * invariant subspace (by their position in a list of 00447 * eigenvalues ordered by increasing real part (if ISRT=0) or 00448 * by increasing imaginary part (if ISRT=1)). The next N**2 00449 * lines contain the matrix rowwise. The last line contains the 00450 * reciprocal condition number for the average of the selected 00451 * eigenvalues, and the reciprocal condition number for the 00452 * corresponding right invariant subspace. The end of data in 00453 * indicated by a line containing N=0, M=0, and ISRT = 0. Even 00454 * if no data is to be tested, there must be at least one line 00455 * containing N=0, M=0 and ISRT=0. 00456 * 00457 *----------------------------------------------------------------------- 00458 * 00459 * ZGG input file: 00460 * 00461 * line 2: NN, INTEGER 00462 * Number of values of N. 00463 * 00464 * line 3: NVAL, INTEGER array, dimension (NN) 00465 * The values for the matrix dimension N. 00466 * 00467 * line 4: NPARMS, INTEGER 00468 * Number of values of the parameters NB, NBMIN, NBCOL, NS, and 00469 * MAXB. 00470 * 00471 * line 5: NBVAL, INTEGER array, dimension (NPARMS) 00472 * The values for the blocksize NB. 00473 * 00474 * line 6: NBMIN, INTEGER array, dimension (NPARMS) 00475 * The values for NBMIN, the minimum row dimension for blocks. 00476 * 00477 * line 7: NSVAL, INTEGER array, dimension (NPARMS) 00478 * The values for the number of shifts. 00479 * 00480 * line 8: MXBVAL, INTEGER array, dimension (NPARMS) 00481 * The values for MAXB, used in determining minimum blocksize. 00482 * 00483 * line 9: NBCOL, INTEGER array, dimension (NPARMS) 00484 * The values for NBCOL, the minimum column dimension for 00485 * blocks. 00486 * 00487 * line 10: THRESH 00488 * Threshold value for the test ratios. Information will be 00489 * printed about each test for which the test ratio is greater 00490 * than or equal to the threshold. 00491 * 00492 * line 11: TSTCHK, LOGICAL 00493 * Flag indicating whether or not to test the LAPACK routines. 00494 * 00495 * line 12: TSTDRV, LOGICAL 00496 * Flag indicating whether or not to test the driver routines. 00497 * 00498 * line 13: TSTERR, LOGICAL 00499 * Flag indicating whether or not to test the error exits for 00500 * the LAPACK routines and driver routines. 00501 * 00502 * line 14: NEWSD, INTEGER 00503 * A code indicating how to set the random number seed. 00504 * = 0: Set the seed to a default value before each run 00505 * = 1: Initialize the seed to a default value only before the 00506 * first run 00507 * = 2: Like 1, but use the seed values on the next line 00508 * 00509 * If line 14 was 2: 00510 * 00511 * line 15: INTEGER array, dimension (4) 00512 * Four integer values for the random number seed. 00513 * 00514 * lines 16-EOF: Lines specifying matrix types, as for NEP. 00515 * The 3-character path name is 'ZGG' for the generalized 00516 * eigenvalue problem routines and driver routines. 00517 * 00518 *----------------------------------------------------------------------- 00519 * 00520 * ZGS and ZGV input files: 00521 * 00522 * line 1: 'ZGS' or 'ZGV' in columns 1 to 3. 00523 * 00524 * line 2: NN, INTEGER 00525 * Number of values of N. 00526 * 00527 * line 3: NVAL, INTEGER array, dimension(NN) 00528 * Dimensions of matrices to be tested. 00529 * 00530 * line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 00531 * These integer parameters determine how blocking is done 00532 * (see ILAENV for details) 00533 * NB : block size 00534 * NBMIN : minimum block size 00535 * NX : minimum dimension for blocking 00536 * NS : number of shifts in xHGEQR 00537 * NBCOL : minimum column dimension for blocking 00538 * 00539 * line 5: THRESH, REAL 00540 * The test threshold against which computed residuals are 00541 * compared. Should generally be in the range from 10. to 20. 00542 * If it is 0., all test case data will be printed. 00543 * 00544 * line 6: TSTERR, LOGICAL 00545 * Flag indicating whether or not to test the error exits. 00546 * 00547 * line 7: NEWSD, INTEGER 00548 * A code indicating how to set the random number seed. 00549 * = 0: Set the seed to a default value before each run 00550 * = 1: Initialize the seed to a default value only before the 00551 * first run 00552 * = 2: Like 1, but use the seed values on the next line 00553 * 00554 * If line 17 was 2: 00555 * 00556 * line 7: INTEGER array, dimension (4) 00557 * Four integer values for the random number seed. 00558 * 00559 * lines 7-EOF: Lines specifying matrix types, as for NEP. 00560 * The 3-character path name is 'ZGS' for the generalized 00561 * eigenvalue problem routines and driver routines. 00562 * 00563 *----------------------------------------------------------------------- 00564 * 00565 * ZGX input file: 00566 * line 1: 'ZGX' in columns 1 to 3. 00567 * 00568 * line 2: N, INTEGER 00569 * Value of N. 00570 * 00571 * line 3: NB, NBMIN, NX, NS, NBCOL, INTEGERs 00572 * These integer parameters determine how blocking is done 00573 * (see ILAENV for details) 00574 * NB : block size 00575 * NBMIN : minimum block size 00576 * NX : minimum dimension for blocking 00577 * NS : number of shifts in xHGEQR 00578 * NBCOL : minimum column dimension for blocking 00579 * 00580 * line 4: THRESH, REAL 00581 * The test threshold against which computed residuals are 00582 * compared. Should generally be in the range from 10. to 20. 00583 * Information will be printed about each test for which the 00584 * test ratio is greater than or equal to the threshold. 00585 * 00586 * line 5: TSTERR, LOGICAL 00587 * Flag indicating whether or not to test the error exits for 00588 * the LAPACK routines and driver routines. 00589 * 00590 * line 6: NEWSD, INTEGER 00591 * A code indicating how to set the random number seed. 00592 * = 0: Set the seed to a default value before each run 00593 * = 1: Initialize the seed to a default value only before the 00594 * first run 00595 * = 2: Like 1, but use the seed values on the next line 00596 * 00597 * If line 6 was 2: 00598 * 00599 * line 7: INTEGER array, dimension (4) 00600 * Four integer values for the random number seed. 00601 * 00602 * If line 2 was 0: 00603 * 00604 * line 7-EOF: Precomputed examples are tested. 00605 * 00606 * remaining lines : Each example is stored on 3+2*N*N lines, where N is 00607 * its dimension. The first line contains the dimension (a 00608 * single integer). The next line contains an integer k such 00609 * that only the last k eigenvalues will be selected and appear 00610 * in the leading diagonal blocks of $A$ and $B$. The next N*N 00611 * lines contain the matrix A, one element per line. The next N*N 00612 * lines contain the matrix B. The last line contains the 00613 * reciprocal of the eigenvalue cluster condition number and the 00614 * reciprocal of the deflating subspace (associated with the 00615 * selected eigencluster) condition number. The end of data is 00616 * indicated by dimension N=0. Even if no data is to be tested, 00617 * there must be at least one line containing N=0. 00618 * 00619 *----------------------------------------------------------------------- 00620 * 00621 * ZXV input files: 00622 * line 1: 'ZXV' in columns 1 to 3. 00623 * 00624 * line 2: N, INTEGER 00625 * Value of N. 00626 * 00627 * line 3: NB, NBMIN, NX, NS, NBCOL, INTEGERs 00628 * These integer parameters determine how blocking is done 00629 * (see ILAENV for details) 00630 * NB : block size 00631 * NBMIN : minimum block size 00632 * NX : minimum dimension for blocking 00633 * NS : number of shifts in xHGEQR 00634 * NBCOL : minimum column dimension for blocking 00635 * 00636 * line 4: THRESH, REAL 00637 * The test threshold against which computed residuals are 00638 * compared. Should generally be in the range from 10. to 20. 00639 * Information will be printed about each test for which the 00640 * test ratio is greater than or equal to the threshold. 00641 * 00642 * line 5: TSTERR, LOGICAL 00643 * Flag indicating whether or not to test the error exits for 00644 * the LAPACK routines and driver routines. 00645 * 00646 * line 6: NEWSD, INTEGER 00647 * A code indicating how to set the random number seed. 00648 * = 0: Set the seed to a default value before each run 00649 * = 1: Initialize the seed to a default value only before the 00650 * first run 00651 * = 2: Like 1, but use the seed values on the next line 00652 * 00653 * If line 6 was 2: 00654 * 00655 * line 7: INTEGER array, dimension (4) 00656 * Four integer values for the random number seed. 00657 * 00658 * If line 2 was 0: 00659 * 00660 * line 7-EOF: Precomputed examples are tested. 00661 * 00662 * remaining lines : Each example is stored on 3+2*N*N lines, where N is 00663 * its dimension. The first line contains the dimension (a 00664 * single integer). The next N*N lines contain the matrix A, one 00665 * element per line. The next N*N lines contain the matrix B. 00666 * The next line contains the reciprocals of the eigenvalue 00667 * condition numbers. The last line contains the reciprocals of 00668 * the eigenvector condition numbers. The end of data is 00669 * indicated by dimension N=0. Even if no data is to be tested, 00670 * there must be at least one line containing N=0. 00671 * 00672 *----------------------------------------------------------------------- 00673 * 00674 * ZHB input file: 00675 * 00676 * line 2: NN, INTEGER 00677 * Number of values of N. 00678 * 00679 * line 3: NVAL, INTEGER array, dimension (NN) 00680 * The values for the matrix dimension N. 00681 * 00682 * line 4: NK, INTEGER 00683 * Number of values of K. 00684 * 00685 * line 5: KVAL, INTEGER array, dimension (NK) 00686 * The values for the matrix dimension K. 00687 * 00688 * line 6: THRESH 00689 * Threshold value for the test ratios. Information will be 00690 * printed about each test for which the test ratio is greater 00691 * than or equal to the threshold. 00692 * 00693 * line 7: NEWSD, INTEGER 00694 * A code indicating how to set the random number seed. 00695 * = 0: Set the seed to a default value before each run 00696 * = 1: Initialize the seed to a default value only before the 00697 * first run 00698 * = 2: Like 1, but use the seed values on the next line 00699 * 00700 * If line 7 was 2: 00701 * 00702 * line 8: INTEGER array, dimension (4) 00703 * Four integer values for the random number seed. 00704 * 00705 * lines 8-EOF: Lines specifying matrix types, as for NEP. 00706 * The 3-character path name is 'ZHB'. 00707 * 00708 *----------------------------------------------------------------------- 00709 * 00710 * ZBB input file: 00711 * 00712 * line 2: NN, INTEGER 00713 * Number of values of M and N. 00714 * 00715 * line 3: MVAL, INTEGER array, dimension (NN) 00716 * The values for the matrix row dimension M. 00717 * 00718 * line 4: NVAL, INTEGER array, dimension (NN) 00719 * The values for the matrix column dimension N. 00720 * 00721 * line 4: NK, INTEGER 00722 * Number of values of K. 00723 * 00724 * line 5: KVAL, INTEGER array, dimension (NK) 00725 * The values for the matrix bandwidth K. 00726 * 00727 * line 6: NPARMS, INTEGER 00728 * Number of values of the parameter NRHS 00729 * 00730 * line 7: NSVAL, INTEGER array, dimension (NPARMS) 00731 * The values for the number of right hand sides NRHS. 00732 * 00733 * line 8: THRESH 00734 * Threshold value for the test ratios. Information will be 00735 * printed about each test for which the test ratio is greater 00736 * than or equal to the threshold. 00737 * 00738 * line 9: NEWSD, INTEGER 00739 * A code indicating how to set the random number seed. 00740 * = 0: Set the seed to a default value before each run 00741 * = 1: Initialize the seed to a default value only before the 00742 * first run 00743 * = 2: Like 1, but use the seed values on the next line 00744 * 00745 * If line 9 was 2: 00746 * 00747 * line 10: INTEGER array, dimension (4) 00748 * Four integer values for the random number seed. 00749 * 00750 * lines 10-EOF: Lines specifying matrix types, as for SVD. 00751 * The 3-character path name is 'ZBB'. 00752 * 00753 *----------------------------------------------------------------------- 00754 * 00755 * ZEC input file: 00756 * 00757 * line 2: THRESH, REAL 00758 * Threshold value for the test ratios. Information will be 00759 * printed about each test for which the test ratio is greater 00760 * than or equal to the threshold. 00761 * 00762 * lines 3-EOF: 00763 * 00764 * Input for testing the eigencondition routines consists of a set of 00765 * specially constructed test cases and their solutions. The data 00766 * format is not intended to be modified by the user. 00767 * 00768 *----------------------------------------------------------------------- 00769 * 00770 * ZBL and ZBK input files: 00771 * 00772 * line 1: 'ZBL' in columns 1-3 to test CGEBAL, or 'ZBK' in 00773 * columns 1-3 to test CGEBAK. 00774 * 00775 * The remaining lines consist of specially constructed test cases. 00776 * 00777 *----------------------------------------------------------------------- 00778 * 00779 * ZGL and ZGK input files: 00780 * 00781 * line 1: 'ZGL' in columns 1-3 to test ZGGBAL, or 'ZGK' in 00782 * columns 1-3 to test ZGGBAK. 00783 * 00784 * The remaining lines consist of specially constructed test cases. 00785 * 00786 *----------------------------------------------------------------------- 00787 * 00788 * GLM data file: 00789 * 00790 * line 1: 'GLM' in columns 1 to 3. 00791 * 00792 * line 2: NN, INTEGER 00793 * Number of values of M, P, and N. 00794 * 00795 * line 3: MVAL, INTEGER array, dimension(NN) 00796 * Values of M (row dimension). 00797 * 00798 * line 4: PVAL, INTEGER array, dimension(NN) 00799 * Values of P (row dimension). 00800 * 00801 * line 5: NVAL, INTEGER array, dimension(NN) 00802 * Values of N (column dimension), note M <= N <= M+P. 00803 * 00804 * line 6: THRESH, REAL 00805 * Threshold value for the test ratios. Information will be 00806 * printed about each test for which the test ratio is greater 00807 * than or equal to the threshold. 00808 * 00809 * line 7: TSTERR, LOGICAL 00810 * Flag indicating whether or not to test the error exits for 00811 * the LAPACK routines and driver routines. 00812 * 00813 * line 8: NEWSD, INTEGER 00814 * A code indicating how to set the random number seed. 00815 * = 0: Set the seed to a default value before each run 00816 * = 1: Initialize the seed to a default value only before the 00817 * first run 00818 * = 2: Like 1, but use the seed values on the next line 00819 * 00820 * If line 8 was 2: 00821 * 00822 * line 9: INTEGER array, dimension (4) 00823 * Four integer values for the random number seed. 00824 * 00825 * lines 9-EOF: Lines specifying matrix types, as for NEP. 00826 * The 3-character path name is 'GLM' for the generalized 00827 * linear regression model routines. 00828 * 00829 *----------------------------------------------------------------------- 00830 * 00831 * GQR data file: 00832 * 00833 * line 1: 'GQR' in columns 1 to 3. 00834 * 00835 * line 2: NN, INTEGER 00836 * Number of values of M, P, and N. 00837 * 00838 * line 3: MVAL, INTEGER array, dimension(NN) 00839 * Values of M. 00840 * 00841 * line 4: PVAL, INTEGER array, dimension(NN) 00842 * Values of P. 00843 * 00844 * line 5: NVAL, INTEGER array, dimension(NN) 00845 * Values of N. 00846 * 00847 * line 6: THRESH, REAL 00848 * Threshold value for the test ratios. Information will be 00849 * printed about each test for which the test ratio is greater 00850 * than or equal to the threshold. 00851 * 00852 * line 7: TSTERR, LOGICAL 00853 * Flag indicating whether or not to test the error exits for 00854 * the LAPACK routines and driver routines. 00855 * 00856 * line 8: NEWSD, INTEGER 00857 * A code indicating how to set the random number seed. 00858 * = 0: Set the seed to a default value before each run 00859 * = 1: Initialize the seed to a default value only before the 00860 * first run 00861 * = 2: Like 1, but use the seed values on the next line 00862 * 00863 * If line 8 was 2: 00864 * 00865 * line 9: INTEGER array, dimension (4) 00866 * Four integer values for the random number seed. 00867 * 00868 * lines 9-EOF: Lines specifying matrix types, as for NEP. 00869 * The 3-character path name is 'GQR' for the generalized 00870 * QR and RQ routines. 00871 * 00872 *----------------------------------------------------------------------- 00873 * 00874 * GSV data file: 00875 * 00876 * line 1: 'GSV' in columns 1 to 3. 00877 * 00878 * line 2: NN, INTEGER 00879 * Number of values of M, P, and N. 00880 * 00881 * line 3: MVAL, INTEGER array, dimension(NN) 00882 * Values of M (row dimension). 00883 * 00884 * line 4: PVAL, INTEGER array, dimension(NN) 00885 * Values of P (row dimension). 00886 * 00887 * line 5: NVAL, INTEGER array, dimension(NN) 00888 * Values of N (column dimension). 00889 * 00890 * line 6: THRESH, REAL 00891 * Threshold value for the test ratios. Information will be 00892 * printed about each test for which the test ratio is greater 00893 * than or equal to the threshold. 00894 * 00895 * line 7: TSTERR, LOGICAL 00896 * Flag indicating whether or not to test the error exits for 00897 * the LAPACK routines and driver routines. 00898 * 00899 * line 8: NEWSD, INTEGER 00900 * A code indicating how to set the random number seed. 00901 * = 0: Set the seed to a default value before each run 00902 * = 1: Initialize the seed to a default value only before the 00903 * first run 00904 * = 2: Like 1, but use the seed values on the next line 00905 * 00906 * If line 8 was 2: 00907 * 00908 * line 9: INTEGER array, dimension (4) 00909 * Four integer values for the random number seed. 00910 * 00911 * lines 9-EOF: Lines specifying matrix types, as for NEP. 00912 * The 3-character path name is 'GSV' for the generalized 00913 * SVD routines. 00914 * 00915 *----------------------------------------------------------------------- 00916 * 00917 * CSD data file: 00918 * 00919 * line 1: 'CSD' in columns 1 to 3. 00920 * 00921 * line 2: NM, INTEGER 00922 * Number of values of M, P, and N. 00923 * 00924 * line 3: MVAL, INTEGER array, dimension(NM) 00925 * Values of M (row and column dimension of orthogonal matrix). 00926 * 00927 * line 4: PVAL, INTEGER array, dimension(NM) 00928 * Values of P (row dimension of top-left block). 00929 * 00930 * line 5: NVAL, INTEGER array, dimension(NM) 00931 * Values of N (column dimension of top-left block). 00932 * 00933 * line 6: THRESH, REAL 00934 * Threshold value for the test ratios. Information will be 00935 * printed about each test for which the test ratio is greater 00936 * than or equal to the threshold. 00937 * 00938 * line 7: TSTERR, LOGICAL 00939 * Flag indicating whether or not to test the error exits for 00940 * the LAPACK routines and driver routines. 00941 * 00942 * line 8: NEWSD, INTEGER 00943 * A code indicating how to set the random number seed. 00944 * = 0: Set the seed to a default value before each run 00945 * = 1: Initialize the seed to a default value only before the 00946 * first run 00947 * = 2: Like 1, but use the seed values on the next line 00948 * 00949 * If line 8 was 2: 00950 * 00951 * line 9: INTEGER array, dimension (4) 00952 * Four integer values for the random number seed. 00953 * 00954 * lines 9-EOF: Lines specifying matrix types, as for NEP. 00955 * The 3-character path name is 'CSD' for the CSD routine. 00956 * 00957 *----------------------------------------------------------------------- 00958 * 00959 * LSE data file: 00960 * 00961 * line 1: 'LSE' in columns 1 to 3. 00962 * 00963 * line 2: NN, INTEGER 00964 * Number of values of M, P, and N. 00965 * 00966 * line 3: MVAL, INTEGER array, dimension(NN) 00967 * Values of M. 00968 * 00969 * line 4: PVAL, INTEGER array, dimension(NN) 00970 * Values of P. 00971 * 00972 * line 5: NVAL, INTEGER array, dimension(NN) 00973 * Values of N, note P <= N <= P+M. 00974 * 00975 * line 6: THRESH, REAL 00976 * Threshold value for the test ratios. Information will be 00977 * printed about each test for which the test ratio is greater 00978 * than or equal to the threshold. 00979 * 00980 * line 7: TSTERR, LOGICAL 00981 * Flag indicating whether or not to test the error exits for 00982 * the LAPACK routines and driver routines. 00983 * 00984 * line 8: NEWSD, INTEGER 00985 * A code indicating how to set the random number seed. 00986 * = 0: Set the seed to a default value before each run 00987 * = 1: Initialize the seed to a default value only before the 00988 * first run 00989 * = 2: Like 1, but use the seed values on the next line 00990 * 00991 * If line 8 was 2: 00992 * 00993 * line 9: INTEGER array, dimension (4) 00994 * Four integer values for the random number seed. 00995 * 00996 * lines 9-EOF: Lines specifying matrix types, as for NEP. 00997 * The 3-character path name is 'GSV' for the generalized 00998 * SVD routines. 00999 * 01000 *----------------------------------------------------------------------- 01001 * 01002 * NMAX is currently set to 132 and must be at least 12 for some of the 01003 * precomputed examples, and LWORK = NMAX*(5*NMAX+20) in the parameter 01004 * statements below. For SVD, we assume NRHS may be as big as N. The 01005 * parameter NEED is set to 14 to allow for 14 N-by-N matrices for ZGG. 01006 * 01007 * ===================================================================== 01008 * 01009 * .. Parameters .. 01010 INTEGER NMAX 01011 PARAMETER ( NMAX = 132 ) 01012 INTEGER NCMAX 01013 PARAMETER ( NCMAX = 20 ) 01014 INTEGER NEED 01015 PARAMETER ( NEED = 14 ) 01016 INTEGER LWORK 01017 PARAMETER ( LWORK = NMAX*( 5*NMAX+20 ) ) 01018 INTEGER LIWORK 01019 PARAMETER ( LIWORK = NMAX*( NMAX+20 ) ) 01020 INTEGER MAXIN 01021 PARAMETER ( MAXIN = 20 ) 01022 INTEGER MAXT 01023 PARAMETER ( MAXT = 30 ) 01024 INTEGER NIN, NOUT 01025 PARAMETER ( NIN = 5, NOUT = 6 ) 01026 * .. 01027 * .. Local Scalars .. 01028 LOGICAL ZBK, ZBL, ZES, ZEV, ZGK, ZGL, ZGS, ZGV, ZGX, 01029 $ ZSX, ZVX, ZXV, CSD, FATAL, GLM, GQR, GSV, LSE, 01030 $ NEP, SEP, SVD, TSTCHK, TSTDIF, TSTDRV, TSTERR, 01031 $ ZBB, ZGG, ZHB 01032 CHARACTER C1 01033 CHARACTER*3 C3, PATH 01034 CHARACTER*32 VNAME 01035 CHARACTER*10 INTSTR 01036 CHARACTER*80 LINE 01037 INTEGER I, I1, IC, INFO, ITMP, K, LENP, MAXTYP, NEWSD, 01038 $ NK, NN, NPARMS, NRHS, NTYPES, 01039 $ VERS_MAJOR, VERS_MINOR, VERS_PATCH 01040 DOUBLE PRECISION EPS, S1, S2, THRESH, THRSHN 01041 * .. 01042 * .. Local Arrays .. 01043 LOGICAL DOTYPE( MAXT ), LOGWRK( NMAX ) 01044 INTEGER IOLDSD( 4 ), ISEED( 4 ), IWORK( LIWORK ), 01045 $ KVAL( MAXIN ), MVAL( MAXIN ), MXBVAL( MAXIN ), 01046 $ NBCOL( MAXIN ), NBMIN( MAXIN ), NBVAL( MAXIN ), 01047 $ NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ), 01048 $ PVAL( MAXIN ) 01049 INTEGER INMIN( MAXIN ), INWIN( MAXIN ), INIBL( MAXIN ), 01050 $ ISHFTS( MAXIN ), IACC22( MAXIN ) 01051 DOUBLE PRECISION ALPHA( NMAX ), BETA( NMAX ), DR( NMAX, 12 ), 01052 $ RESULT( 500 ), RWORK( LWORK ), S( NMAX*NMAX ) 01053 COMPLEX*16 A( NMAX*NMAX, NEED ), B( NMAX*NMAX, 5 ), 01054 $ C( NCMAX*NCMAX, NCMAX*NCMAX ), DC( NMAX, 6 ), 01055 $ TAUA( NMAX ), TAUB( NMAX ), WORK( LWORK ), 01056 $ X( 5*NMAX ) 01057 * .. 01058 * .. External Functions .. 01059 LOGICAL LSAMEN 01060 DOUBLE PRECISION DLAMCH, DSECND 01061 EXTERNAL LSAMEN, DLAMCH, DSECND 01062 * .. 01063 * .. External Subroutines .. 01064 EXTERNAL ALAREQ, XLAENV, ZCHKBB, ZCHKBD, ZCHKBK, ZCHKBL, 01065 $ ZCHKEC, ZCHKGG, ZCHKGK, ZCHKGL, ZCHKHB, ZCHKHS, 01066 $ ZCHKST, ZCKCSD, ZCKGLM, ZCKGQR, ZCKGSV, ZCKLSE, 01067 $ ZDRGES, ZDRGEV, ZDRGSX, ZDRGVX, ZDRVBD, ZDRVES, 01068 $ ZDRVEV, ZDRVGG, ZDRVSG, ZDRVST, ZDRVSX, ZDRVVX, 01069 $ ZERRBD, ZERRED, ZERRGG, ZERRHS, ZERRST, ILAVER 01070 * .. 01071 * .. Intrinsic Functions .. 01072 INTRINSIC LEN, MIN 01073 * .. 01074 * .. Scalars in Common .. 01075 LOGICAL LERR, OK 01076 CHARACTER*32 SRNAMT 01077 INTEGER INFOT, MAXB, NPROC, NSHIFT, NUNIT, SELDIM, 01078 $ SELOPT 01079 * .. 01080 * .. Arrays in Common .. 01081 LOGICAL SELVAL( 20 ) 01082 INTEGER IPARMS( 100 ) 01083 DOUBLE PRECISION SELWI( 20 ), SELWR( 20 ) 01084 * .. 01085 * .. Common blocks .. 01086 COMMON / CENVIR / NPROC, NSHIFT, MAXB 01087 COMMON / INFOC / INFOT, NUNIT, OK, LERR 01088 COMMON / SRNAMC / SRNAMT 01089 COMMON / SSLCT / SELOPT, SELDIM, SELVAL, SELWR, SELWI 01090 COMMON / CLAENV / IPARMS 01091 * .. 01092 * .. Data statements .. 01093 DATA INTSTR / '0123456789' / 01094 DATA IOLDSD / 0, 0, 0, 1 / 01095 * .. 01096 * .. Executable Statements .. 01097 * 01098 S1 = DSECND( ) 01099 FATAL = .FALSE. 01100 NUNIT = NOUT 01101 * 01102 * Return to here to read multiple sets of data 01103 * 01104 10 CONTINUE 01105 * 01106 * Read the first line and set the 3-character test path 01107 * 01108 READ( NIN, FMT = '(A80)', END = 380 )LINE 01109 PATH = LINE( 1: 3 ) 01110 NEP = LSAMEN( 3, PATH, 'NEP' ) .OR. LSAMEN( 3, PATH, 'ZHS' ) 01111 SEP = LSAMEN( 3, PATH, 'SEP' ) .OR. LSAMEN( 3, PATH, 'ZST' ) .OR. 01112 $ LSAMEN( 3, PATH, 'ZSG' ) 01113 SVD = LSAMEN( 3, PATH, 'SVD' ) .OR. LSAMEN( 3, PATH, 'ZBD' ) 01114 ZEV = LSAMEN( 3, PATH, 'ZEV' ) 01115 ZES = LSAMEN( 3, PATH, 'ZES' ) 01116 ZVX = LSAMEN( 3, PATH, 'ZVX' ) 01117 ZSX = LSAMEN( 3, PATH, 'ZSX' ) 01118 ZGG = LSAMEN( 3, PATH, 'ZGG' ) 01119 ZGS = LSAMEN( 3, PATH, 'ZGS' ) 01120 ZGX = LSAMEN( 3, PATH, 'ZGX' ) 01121 ZGV = LSAMEN( 3, PATH, 'ZGV' ) 01122 ZXV = LSAMEN( 3, PATH, 'ZXV' ) 01123 ZHB = LSAMEN( 3, PATH, 'ZHB' ) 01124 ZBB = LSAMEN( 3, PATH, 'ZBB' ) 01125 GLM = LSAMEN( 3, PATH, 'GLM' ) 01126 GQR = LSAMEN( 3, PATH, 'GQR' ) .OR. LSAMEN( 3, PATH, 'GRQ' ) 01127 GSV = LSAMEN( 3, PATH, 'GSV' ) 01128 CSD = LSAMEN( 3, PATH, 'CSD' ) 01129 LSE = LSAMEN( 3, PATH, 'LSE' ) 01130 ZBL = LSAMEN( 3, PATH, 'ZBL' ) 01131 ZBK = LSAMEN( 3, PATH, 'ZBK' ) 01132 ZGL = LSAMEN( 3, PATH, 'ZGL' ) 01133 ZGK = LSAMEN( 3, PATH, 'ZGK' ) 01134 * 01135 * Report values of parameters. 01136 * 01137 IF( PATH.EQ.' ' ) THEN 01138 GO TO 10 01139 ELSE IF( NEP ) THEN 01140 WRITE( NOUT, FMT = 9987 ) 01141 ELSE IF( SEP ) THEN 01142 WRITE( NOUT, FMT = 9986 ) 01143 ELSE IF( SVD ) THEN 01144 WRITE( NOUT, FMT = 9985 ) 01145 ELSE IF( ZEV ) THEN 01146 WRITE( NOUT, FMT = 9979 ) 01147 ELSE IF( ZES ) THEN 01148 WRITE( NOUT, FMT = 9978 ) 01149 ELSE IF( ZVX ) THEN 01150 WRITE( NOUT, FMT = 9977 ) 01151 ELSE IF( ZSX ) THEN 01152 WRITE( NOUT, FMT = 9976 ) 01153 ELSE IF( ZGG ) THEN 01154 WRITE( NOUT, FMT = 9975 ) 01155 ELSE IF( ZGS ) THEN 01156 WRITE( NOUT, FMT = 9964 ) 01157 ELSE IF( ZGX ) THEN 01158 WRITE( NOUT, FMT = 9965 ) 01159 ELSE IF( ZGV ) THEN 01160 WRITE( NOUT, FMT = 9963 ) 01161 ELSE IF( ZXV ) THEN 01162 WRITE( NOUT, FMT = 9962 ) 01163 ELSE IF( ZHB ) THEN 01164 WRITE( NOUT, FMT = 9974 ) 01165 ELSE IF( ZBB ) THEN 01166 WRITE( NOUT, FMT = 9967 ) 01167 ELSE IF( GLM ) THEN 01168 WRITE( NOUT, FMT = 9971 ) 01169 ELSE IF( GQR ) THEN 01170 WRITE( NOUT, FMT = 9970 ) 01171 ELSE IF( GSV ) THEN 01172 WRITE( NOUT, FMT = 9969 ) 01173 ELSE IF( CSD ) THEN 01174 WRITE( NOUT, FMT = 9960 ) 01175 ELSE IF( LSE ) THEN 01176 WRITE( NOUT, FMT = 9968 ) 01177 ELSE IF( ZBL ) THEN 01178 * 01179 * ZGEBAL: Balancing 01180 * 01181 CALL ZCHKBL( NIN, NOUT ) 01182 GO TO 380 01183 ELSE IF( ZBK ) THEN 01184 * 01185 * ZGEBAK: Back transformation 01186 * 01187 CALL ZCHKBK( NIN, NOUT ) 01188 GO TO 380 01189 ELSE IF( ZGL ) THEN 01190 * 01191 * ZGGBAL: Balancing 01192 * 01193 CALL ZCHKGL( NIN, NOUT ) 01194 GO TO 380 01195 ELSE IF( ZGK ) THEN 01196 * 01197 * ZGGBAK: Back transformation 01198 * 01199 CALL ZCHKGK( NIN, NOUT ) 01200 GO TO 380 01201 ELSE IF( LSAMEN( 3, PATH, 'ZEC' ) ) THEN 01202 * 01203 * ZEC: Eigencondition estimation 01204 * 01205 READ( NIN, FMT = * )THRESH 01206 CALL XLAENV( 1, 1 ) 01207 TSTERR = .TRUE. 01208 CALL ZCHKEC( THRESH, TSTERR, NIN, NOUT ) 01209 GO TO 380 01210 ELSE 01211 WRITE( NOUT, FMT = 9992 )PATH 01212 GO TO 380 01213 END IF 01214 CALL ILAVER( VERS_MAJOR, VERS_MINOR, VERS_PATCH ) 01215 WRITE( NOUT, FMT = 9972 ) VERS_MAJOR, VERS_MINOR, VERS_PATCH 01216 WRITE( NOUT, FMT = 9984 ) 01217 * 01218 * Read the number of values of M, P, and N. 01219 * 01220 READ( NIN, FMT = * )NN 01221 IF( NN.LT.0 ) THEN 01222 WRITE( NOUT, FMT = 9989 )' NN ', NN, 1 01223 NN = 0 01224 FATAL = .TRUE. 01225 ELSE IF( NN.GT.MAXIN ) THEN 01226 WRITE( NOUT, FMT = 9988 )' NN ', NN, MAXIN 01227 NN = 0 01228 FATAL = .TRUE. 01229 END IF 01230 * 01231 * Read the values of M 01232 * 01233 IF( .NOT.( ZGX .OR. ZXV ) ) THEN 01234 READ( NIN, FMT = * )( MVAL( I ), I = 1, NN ) 01235 IF( SVD ) THEN 01236 VNAME = ' M ' 01237 ELSE 01238 VNAME = ' N ' 01239 END IF 01240 DO 20 I = 1, NN 01241 IF( MVAL( I ).LT.0 ) THEN 01242 WRITE( NOUT, FMT = 9989 )VNAME, MVAL( I ), 0 01243 FATAL = .TRUE. 01244 ELSE IF( MVAL( I ).GT.NMAX ) THEN 01245 WRITE( NOUT, FMT = 9988 )VNAME, MVAL( I ), NMAX 01246 FATAL = .TRUE. 01247 END IF 01248 20 CONTINUE 01249 WRITE( NOUT, FMT = 9983 )'M: ', ( MVAL( I ), I = 1, NN ) 01250 END IF 01251 * 01252 * Read the values of P 01253 * 01254 IF( GLM .OR. GQR .OR. GSV .OR. CSD .OR. LSE ) THEN 01255 READ( NIN, FMT = * )( PVAL( I ), I = 1, NN ) 01256 DO 30 I = 1, NN 01257 IF( PVAL( I ).LT.0 ) THEN 01258 WRITE( NOUT, FMT = 9989 )' P ', PVAL( I ), 0 01259 FATAL = .TRUE. 01260 ELSE IF( PVAL( I ).GT.NMAX ) THEN 01261 WRITE( NOUT, FMT = 9988 )' P ', PVAL( I ), NMAX 01262 FATAL = .TRUE. 01263 END IF 01264 30 CONTINUE 01265 WRITE( NOUT, FMT = 9983 )'P: ', ( PVAL( I ), I = 1, NN ) 01266 END IF 01267 * 01268 * Read the values of N 01269 * 01270 IF( SVD .OR. ZBB .OR. GLM .OR. GQR .OR. GSV .OR. CSD .OR. 01271 $ LSE ) THEN 01272 READ( NIN, FMT = * )( NVAL( I ), I = 1, NN ) 01273 DO 40 I = 1, NN 01274 IF( NVAL( I ).LT.0 ) THEN 01275 WRITE( NOUT, FMT = 9989 )' N ', NVAL( I ), 0 01276 FATAL = .TRUE. 01277 ELSE IF( NVAL( I ).GT.NMAX ) THEN 01278 WRITE( NOUT, FMT = 9988 )' N ', NVAL( I ), NMAX 01279 FATAL = .TRUE. 01280 END IF 01281 40 CONTINUE 01282 ELSE 01283 DO 50 I = 1, NN 01284 NVAL( I ) = MVAL( I ) 01285 50 CONTINUE 01286 END IF 01287 IF( .NOT.( ZGX .OR. ZXV ) ) THEN 01288 WRITE( NOUT, FMT = 9983 )'N: ', ( NVAL( I ), I = 1, NN ) 01289 ELSE 01290 WRITE( NOUT, FMT = 9983 )'N: ', NN 01291 END IF 01292 * 01293 * Read the number of values of K, followed by the values of K 01294 * 01295 IF( ZHB .OR. ZBB ) THEN 01296 READ( NIN, FMT = * )NK 01297 READ( NIN, FMT = * )( KVAL( I ), I = 1, NK ) 01298 DO 60 I = 1, NK 01299 IF( KVAL( I ).LT.0 ) THEN 01300 WRITE( NOUT, FMT = 9989 )' K ', KVAL( I ), 0 01301 FATAL = .TRUE. 01302 ELSE IF( KVAL( I ).GT.NMAX ) THEN 01303 WRITE( NOUT, FMT = 9988 )' K ', KVAL( I ), NMAX 01304 FATAL = .TRUE. 01305 END IF 01306 60 CONTINUE 01307 WRITE( NOUT, FMT = 9983 )'K: ', ( KVAL( I ), I = 1, NK ) 01308 END IF 01309 * 01310 IF( ZEV .OR. ZES .OR. ZVX .OR. ZSX ) THEN 01311 * 01312 * For the nonsymmetric QR driver routines, only one set of 01313 * parameters is allowed. 01314 * 01315 READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ), 01316 $ INMIN( 1 ), INWIN( 1 ), INIBL(1), ISHFTS(1), IACC22(1) 01317 IF( NBVAL( 1 ).LT.1 ) THEN 01318 WRITE( NOUT, FMT = 9989 )' NB ', NBVAL( 1 ), 1 01319 FATAL = .TRUE. 01320 ELSE IF( NBMIN( 1 ).LT.1 ) THEN 01321 WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1 01322 FATAL = .TRUE. 01323 ELSE IF( NXVAL( 1 ).LT.1 ) THEN 01324 WRITE( NOUT, FMT = 9989 )' NX ', NXVAL( 1 ), 1 01325 FATAL = .TRUE. 01326 ELSE IF( INMIN( 1 ).LT.1 ) THEN 01327 WRITE( NOUT, FMT = 9989 )' INMIN ', INMIN( 1 ), 1 01328 FATAL = .TRUE. 01329 ELSE IF( INWIN( 1 ).LT.1 ) THEN 01330 WRITE( NOUT, FMT = 9989 )' INWIN ', INWIN( 1 ), 1 01331 FATAL = .TRUE. 01332 ELSE IF( INIBL( 1 ).LT.1 ) THEN 01333 WRITE( NOUT, FMT = 9989 )' INIBL ', INIBL( 1 ), 1 01334 FATAL = .TRUE. 01335 ELSE IF( ISHFTS( 1 ).LT.1 ) THEN 01336 WRITE( NOUT, FMT = 9989 )' ISHFTS ', ISHFTS( 1 ), 1 01337 FATAL = .TRUE. 01338 ELSE IF( IACC22( 1 ).LT.0 ) THEN 01339 WRITE( NOUT, FMT = 9989 )' IACC22 ', IACC22( 1 ), 0 01340 FATAL = .TRUE. 01341 END IF 01342 CALL XLAENV( 1, NBVAL( 1 ) ) 01343 CALL XLAENV( 2, NBMIN( 1 ) ) 01344 CALL XLAENV( 3, NXVAL( 1 ) ) 01345 CALL XLAENV(12, MAX( 11, INMIN( 1 ) ) ) 01346 CALL XLAENV(13, INWIN( 1 ) ) 01347 CALL XLAENV(14, INIBL( 1 ) ) 01348 CALL XLAENV(15, ISHFTS( 1 ) ) 01349 CALL XLAENV(16, IACC22( 1 ) ) 01350 WRITE( NOUT, FMT = 9983 )'NB: ', NBVAL( 1 ) 01351 WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 ) 01352 WRITE( NOUT, FMT = 9983 )'NX: ', NXVAL( 1 ) 01353 WRITE( NOUT, FMT = 9983 )'INMIN: ', INMIN( 1 ) 01354 WRITE( NOUT, FMT = 9983 )'INWIN: ', INWIN( 1 ) 01355 WRITE( NOUT, FMT = 9983 )'INIBL: ', INIBL( 1 ) 01356 WRITE( NOUT, FMT = 9983 )'ISHFTS: ', ISHFTS( 1 ) 01357 WRITE( NOUT, FMT = 9983 )'IACC22: ', IACC22( 1 ) 01358 * 01359 ELSE IF( ZGS .OR. ZGX .OR. ZGV .OR. ZXV ) THEN 01360 * 01361 * For the nonsymmetric generalized driver routines, only one set of 01362 * parameters is allowed. 01363 * 01364 READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ), 01365 $ NSVAL( 1 ), MXBVAL( 1 ) 01366 IF( NBVAL( 1 ).LT.1 ) THEN 01367 WRITE( NOUT, FMT = 9989 )' NB ', NBVAL( 1 ), 1 01368 FATAL = .TRUE. 01369 ELSE IF( NBMIN( 1 ).LT.1 ) THEN 01370 WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1 01371 FATAL = .TRUE. 01372 ELSE IF( NXVAL( 1 ).LT.1 ) THEN 01373 WRITE( NOUT, FMT = 9989 )' NX ', NXVAL( 1 ), 1 01374 FATAL = .TRUE. 01375 ELSE IF( NSVAL( 1 ).LT.2 ) THEN 01376 WRITE( NOUT, FMT = 9989 )' NS ', NSVAL( 1 ), 2 01377 FATAL = .TRUE. 01378 ELSE IF( MXBVAL( 1 ).LT.1 ) THEN 01379 WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( 1 ), 1 01380 FATAL = .TRUE. 01381 END IF 01382 CALL XLAENV( 1, NBVAL( 1 ) ) 01383 CALL XLAENV( 2, NBMIN( 1 ) ) 01384 CALL XLAENV( 3, NXVAL( 1 ) ) 01385 CALL XLAENV( 4, NSVAL( 1 ) ) 01386 CALL XLAENV( 8, MXBVAL( 1 ) ) 01387 WRITE( NOUT, FMT = 9983 )'NB: ', NBVAL( 1 ) 01388 WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 ) 01389 WRITE( NOUT, FMT = 9983 )'NX: ', NXVAL( 1 ) 01390 WRITE( NOUT, FMT = 9983 )'NS: ', NSVAL( 1 ) 01391 WRITE( NOUT, FMT = 9983 )'MAXB: ', MXBVAL( 1 ) 01392 ELSE IF( .NOT.ZHB .AND. .NOT.GLM .AND. .NOT.GQR .AND. .NOT. 01393 $ GSV .AND. .NOT.CSD .AND. .NOT.LSE ) THEN 01394 * 01395 * For the other paths, the number of parameters can be varied 01396 * from the input file. Read the number of parameter values. 01397 * 01398 READ( NIN, FMT = * )NPARMS 01399 IF( NPARMS.LT.1 ) THEN 01400 WRITE( NOUT, FMT = 9989 )'NPARMS', NPARMS, 1 01401 NPARMS = 0 01402 FATAL = .TRUE. 01403 ELSE IF( NPARMS.GT.MAXIN ) THEN 01404 WRITE( NOUT, FMT = 9988 )'NPARMS', NPARMS, MAXIN 01405 NPARMS = 0 01406 FATAL = .TRUE. 01407 END IF 01408 * 01409 * Read the values of NB 01410 * 01411 IF( .NOT.ZBB ) THEN 01412 READ( NIN, FMT = * )( NBVAL( I ), I = 1, NPARMS ) 01413 DO 70 I = 1, NPARMS 01414 IF( NBVAL( I ).LT.0 ) THEN 01415 WRITE( NOUT, FMT = 9989 )' NB ', NBVAL( I ), 0 01416 FATAL = .TRUE. 01417 ELSE IF( NBVAL( I ).GT.NMAX ) THEN 01418 WRITE( NOUT, FMT = 9988 )' NB ', NBVAL( I ), NMAX 01419 FATAL = .TRUE. 01420 END IF 01421 70 CONTINUE 01422 WRITE( NOUT, FMT = 9983 )'NB: ', 01423 $ ( NBVAL( I ), I = 1, NPARMS ) 01424 END IF 01425 * 01426 * Read the values of NBMIN 01427 * 01428 IF( NEP .OR. SEP .OR. SVD .OR. ZGG ) THEN 01429 READ( NIN, FMT = * )( NBMIN( I ), I = 1, NPARMS ) 01430 DO 80 I = 1, NPARMS 01431 IF( NBMIN( I ).LT.0 ) THEN 01432 WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( I ), 0 01433 FATAL = .TRUE. 01434 ELSE IF( NBMIN( I ).GT.NMAX ) THEN 01435 WRITE( NOUT, FMT = 9988 )'NBMIN ', NBMIN( I ), NMAX 01436 FATAL = .TRUE. 01437 END IF 01438 80 CONTINUE 01439 WRITE( NOUT, FMT = 9983 )'NBMIN:', 01440 $ ( NBMIN( I ), I = 1, NPARMS ) 01441 ELSE 01442 DO 90 I = 1, NPARMS 01443 NBMIN( I ) = 1 01444 90 CONTINUE 01445 END IF 01446 * 01447 * Read the values of NX 01448 * 01449 IF( NEP .OR. SEP .OR. SVD ) THEN 01450 READ( NIN, FMT = * )( NXVAL( I ), I = 1, NPARMS ) 01451 DO 100 I = 1, NPARMS 01452 IF( NXVAL( I ).LT.0 ) THEN 01453 WRITE( NOUT, FMT = 9989 )' NX ', NXVAL( I ), 0 01454 FATAL = .TRUE. 01455 ELSE IF( NXVAL( I ).GT.NMAX ) THEN 01456 WRITE( NOUT, FMT = 9988 )' NX ', NXVAL( I ), NMAX 01457 FATAL = .TRUE. 01458 END IF 01459 100 CONTINUE 01460 WRITE( NOUT, FMT = 9983 )'NX: ', 01461 $ ( NXVAL( I ), I = 1, NPARMS ) 01462 ELSE 01463 DO 110 I = 1, NPARMS 01464 NXVAL( I ) = 1 01465 110 CONTINUE 01466 END IF 01467 * 01468 * Read the values of NSHIFT (if ZGG) or NRHS (if SVD 01469 * or ZBB). 01470 * 01471 IF( SVD .OR. ZBB .OR. ZGG ) THEN 01472 READ( NIN, FMT = * )( NSVAL( I ), I = 1, NPARMS ) 01473 DO 120 I = 1, NPARMS 01474 IF( NSVAL( I ).LT.0 ) THEN 01475 WRITE( NOUT, FMT = 9989 )' NS ', NSVAL( I ), 0 01476 FATAL = .TRUE. 01477 ELSE IF( NSVAL( I ).GT.NMAX ) THEN 01478 WRITE( NOUT, FMT = 9988 )' NS ', NSVAL( I ), NMAX 01479 FATAL = .TRUE. 01480 END IF 01481 120 CONTINUE 01482 WRITE( NOUT, FMT = 9983 )'NS: ', 01483 $ ( NSVAL( I ), I = 1, NPARMS ) 01484 ELSE 01485 DO 130 I = 1, NPARMS 01486 NSVAL( I ) = 1 01487 130 CONTINUE 01488 END IF 01489 * 01490 * Read the values for MAXB. 01491 * 01492 IF( ZGG ) THEN 01493 READ( NIN, FMT = * )( MXBVAL( I ), I = 1, NPARMS ) 01494 DO 140 I = 1, NPARMS 01495 IF( MXBVAL( I ).LT.0 ) THEN 01496 WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( I ), 0 01497 FATAL = .TRUE. 01498 ELSE IF( MXBVAL( I ).GT.NMAX ) THEN 01499 WRITE( NOUT, FMT = 9988 )' MAXB ', MXBVAL( I ), NMAX 01500 FATAL = .TRUE. 01501 END IF 01502 140 CONTINUE 01503 WRITE( NOUT, FMT = 9983 )'MAXB: ', 01504 $ ( MXBVAL( I ), I = 1, NPARMS ) 01505 ELSE 01506 DO 150 I = 1, NPARMS 01507 MXBVAL( I ) = 1 01508 150 CONTINUE 01509 END IF 01510 * 01511 * Read the values for INMIN. 01512 * 01513 IF( NEP ) THEN 01514 READ( NIN, FMT = * )( INMIN( I ), I = 1, NPARMS ) 01515 DO 540 I = 1, NPARMS 01516 IF( INMIN( I ).LT.0 ) THEN 01517 WRITE( NOUT, FMT = 9989 )' INMIN ', INMIN( I ), 0 01518 FATAL = .TRUE. 01519 END IF 01520 540 CONTINUE 01521 WRITE( NOUT, FMT = 9983 )'INMIN: ', 01522 $ ( INMIN( I ), I = 1, NPARMS ) 01523 ELSE 01524 DO 550 I = 1, NPARMS 01525 INMIN( I ) = 1 01526 550 CONTINUE 01527 END IF 01528 * 01529 * Read the values for INWIN. 01530 * 01531 IF( NEP ) THEN 01532 READ( NIN, FMT = * )( INWIN( I ), I = 1, NPARMS ) 01533 DO 560 I = 1, NPARMS 01534 IF( INWIN( I ).LT.0 ) THEN 01535 WRITE( NOUT, FMT = 9989 )' INWIN ', INWIN( I ), 0 01536 FATAL = .TRUE. 01537 END IF 01538 560 CONTINUE 01539 WRITE( NOUT, FMT = 9983 )'INWIN: ', 01540 $ ( INWIN( I ), I = 1, NPARMS ) 01541 ELSE 01542 DO 570 I = 1, NPARMS 01543 INWIN( I ) = 1 01544 570 CONTINUE 01545 END IF 01546 * 01547 * Read the values for INIBL. 01548 * 01549 IF( NEP ) THEN 01550 READ( NIN, FMT = * )( INIBL( I ), I = 1, NPARMS ) 01551 DO 580 I = 1, NPARMS 01552 IF( INIBL( I ).LT.0 ) THEN 01553 WRITE( NOUT, FMT = 9989 )' INIBL ', INIBL( I ), 0 01554 FATAL = .TRUE. 01555 END IF 01556 580 CONTINUE 01557 WRITE( NOUT, FMT = 9983 )'INIBL: ', 01558 $ ( INIBL( I ), I = 1, NPARMS ) 01559 ELSE 01560 DO 590 I = 1, NPARMS 01561 INIBL( I ) = 1 01562 590 CONTINUE 01563 END IF 01564 * 01565 * Read the values for ISHFTS. 01566 * 01567 IF( NEP ) THEN 01568 READ( NIN, FMT = * )( ISHFTS( I ), I = 1, NPARMS ) 01569 DO 600 I = 1, NPARMS 01570 IF( ISHFTS( I ).LT.0 ) THEN 01571 WRITE( NOUT, FMT = 9989 )' ISHFTS ', ISHFTS( I ), 0 01572 FATAL = .TRUE. 01573 END IF 01574 600 CONTINUE 01575 WRITE( NOUT, FMT = 9983 )'ISHFTS: ', 01576 $ ( ISHFTS( I ), I = 1, NPARMS ) 01577 ELSE 01578 DO 610 I = 1, NPARMS 01579 ISHFTS( I ) = 1 01580 610 CONTINUE 01581 END IF 01582 * 01583 * Read the values for IACC22. 01584 * 01585 IF( NEP ) THEN 01586 READ( NIN, FMT = * )( IACC22( I ), I = 1, NPARMS ) 01587 DO 620 I = 1, NPARMS 01588 IF( IACC22( I ).LT.0 ) THEN 01589 WRITE( NOUT, FMT = 9989 )' IACC22 ', IACC22( I ), 0 01590 FATAL = .TRUE. 01591 END IF 01592 620 CONTINUE 01593 WRITE( NOUT, FMT = 9983 )'IACC22: ', 01594 $ ( IACC22( I ), I = 1, NPARMS ) 01595 ELSE 01596 DO 630 I = 1, NPARMS 01597 IACC22( I ) = 1 01598 630 CONTINUE 01599 END IF 01600 * 01601 * Read the values for NBCOL. 01602 * 01603 IF( ZGG ) THEN 01604 READ( NIN, FMT = * )( NBCOL( I ), I = 1, NPARMS ) 01605 DO 160 I = 1, NPARMS 01606 IF( NBCOL( I ).LT.0 ) THEN 01607 WRITE( NOUT, FMT = 9989 )'NBCOL ', NBCOL( I ), 0 01608 FATAL = .TRUE. 01609 ELSE IF( NBCOL( I ).GT.NMAX ) THEN 01610 WRITE( NOUT, FMT = 9988 )'NBCOL ', NBCOL( I ), NMAX 01611 FATAL = .TRUE. 01612 END IF 01613 160 CONTINUE 01614 WRITE( NOUT, FMT = 9983 )'NBCOL:', 01615 $ ( NBCOL( I ), I = 1, NPARMS ) 01616 ELSE 01617 DO 170 I = 1, NPARMS 01618 NBCOL( I ) = 1 01619 170 CONTINUE 01620 END IF 01621 END IF 01622 * 01623 * Calculate and print the machine dependent constants. 01624 * 01625 WRITE( NOUT, FMT = * ) 01626 EPS = DLAMCH( 'Underflow threshold' ) 01627 WRITE( NOUT, FMT = 9981 )'underflow', EPS 01628 EPS = DLAMCH( 'Overflow threshold' ) 01629 WRITE( NOUT, FMT = 9981 )'overflow ', EPS 01630 EPS = DLAMCH( 'Epsilon' ) 01631 WRITE( NOUT, FMT = 9981 )'precision', EPS 01632 * 01633 * Read the threshold value for the test ratios. 01634 * 01635 READ( NIN, FMT = * )THRESH 01636 WRITE( NOUT, FMT = 9982 )THRESH 01637 IF( SEP .OR. SVD .OR. ZGG ) THEN 01638 * 01639 * Read the flag that indicates whether to test LAPACK routines. 01640 * 01641 READ( NIN, FMT = * )TSTCHK 01642 * 01643 * Read the flag that indicates whether to test driver routines. 01644 * 01645 READ( NIN, FMT = * )TSTDRV 01646 END IF 01647 * 01648 * Read the flag that indicates whether to test the error exits. 01649 * 01650 READ( NIN, FMT = * )TSTERR 01651 * 01652 * Read the code describing how to set the random number seed. 01653 * 01654 READ( NIN, FMT = * )NEWSD 01655 * 01656 * If NEWSD = 2, read another line with 4 integers for the seed. 01657 * 01658 IF( NEWSD.EQ.2 ) 01659 $ READ( NIN, FMT = * )( IOLDSD( I ), I = 1, 4 ) 01660 * 01661 DO 180 I = 1, 4 01662 ISEED( I ) = IOLDSD( I ) 01663 180 CONTINUE 01664 * 01665 IF( FATAL ) THEN 01666 WRITE( NOUT, FMT = 9999 ) 01667 STOP 01668 END IF 01669 * 01670 * Read the input lines indicating the test path and its parameters. 01671 * The first three characters indicate the test path, and the number 01672 * of test matrix types must be the first nonblank item in columns 01673 * 4-80. 01674 * 01675 190 CONTINUE 01676 * 01677 IF( .NOT.( ZGX .OR. ZXV ) ) THEN 01678 * 01679 200 CONTINUE 01680 READ( NIN, FMT = '(A80)', END = 380 )LINE 01681 C3 = LINE( 1: 3 ) 01682 LENP = LEN( LINE ) 01683 I = 3 01684 ITMP = 0 01685 I1 = 0 01686 210 CONTINUE 01687 I = I + 1 01688 IF( I.GT.LENP ) THEN 01689 IF( I1.GT.0 ) THEN 01690 GO TO 240 01691 ELSE 01692 NTYPES = MAXT 01693 GO TO 240 01694 END IF 01695 END IF 01696 IF( LINE( I: I ).NE.' ' .AND. LINE( I: I ).NE.',' ) THEN 01697 I1 = I 01698 C1 = LINE( I1: I1 ) 01699 * 01700 * Check that a valid integer was read 01701 * 01702 DO 220 K = 1, 10 01703 IF( C1.EQ.INTSTR( K: K ) ) THEN 01704 IC = K - 1 01705 GO TO 230 01706 END IF 01707 220 CONTINUE 01708 WRITE( NOUT, FMT = 9991 )I, LINE 01709 GO TO 200 01710 230 CONTINUE 01711 ITMP = 10*ITMP + IC 01712 GO TO 210 01713 ELSE IF( I1.GT.0 ) THEN 01714 GO TO 240 01715 ELSE 01716 GO TO 210 01717 END IF 01718 240 CONTINUE 01719 NTYPES = ITMP 01720 * 01721 * Skip the tests if NTYPES is <= 0. 01722 * 01723 IF( .NOT.( ZEV .OR. ZES .OR. ZVX .OR. ZSX .OR. ZGV .OR. 01724 $ ZGS ) .AND. NTYPES.LE.0 ) THEN 01725 WRITE( NOUT, FMT = 9990 )C3 01726 GO TO 200 01727 END IF 01728 * 01729 ELSE 01730 IF( ZGX ) 01731 $ C3 = 'ZGX' 01732 IF( ZXV ) 01733 $ C3 = 'ZXV' 01734 END IF 01735 * 01736 * Reset the random number seed. 01737 * 01738 IF( NEWSD.EQ.0 ) THEN 01739 DO 250 K = 1, 4 01740 ISEED( K ) = IOLDSD( K ) 01741 250 CONTINUE 01742 END IF 01743 * 01744 IF( LSAMEN( 3, C3, 'ZHS' ) .OR. LSAMEN( 3, C3, 'NEP' ) ) THEN 01745 * 01746 * ------------------------------------- 01747 * NEP: Nonsymmetric Eigenvalue Problem 01748 * ------------------------------------- 01749 * Vary the parameters 01750 * NB = block size 01751 * NBMIN = minimum block size 01752 * NX = crossover point 01753 * NS = number of shifts 01754 * MAXB = minimum submatrix size 01755 * 01756 MAXTYP = 21 01757 NTYPES = MIN( MAXTYP, NTYPES ) 01758 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 01759 CALL XLAENV( 1, 1 ) 01760 IF( TSTERR ) 01761 $ CALL ZERRHS( 'ZHSEQR', NOUT ) 01762 DO 270 I = 1, NPARMS 01763 CALL XLAENV( 1, NBVAL( I ) ) 01764 CALL XLAENV( 2, NBMIN( I ) ) 01765 CALL XLAENV( 3, NXVAL( I ) ) 01766 CALL XLAENV(12, MAX( 11, INMIN( I ) ) ) 01767 CALL XLAENV(13, INWIN( I ) ) 01768 CALL XLAENV(14, INIBL( I ) ) 01769 CALL XLAENV(15, ISHFTS( I ) ) 01770 CALL XLAENV(16, IACC22( I ) ) 01771 * 01772 IF( NEWSD.EQ.0 ) THEN 01773 DO 260 K = 1, 4 01774 ISEED( K ) = IOLDSD( K ) 01775 260 CONTINUE 01776 END IF 01777 WRITE( NOUT, FMT = 9961 )C3, NBVAL( I ), NBMIN( I ), 01778 $ NXVAL( I ), MAX( 11, INMIN(I)), 01779 $ INWIN( I ), INIBL( I ), ISHFTS( I ), IACC22( I ) 01780 CALL ZCHKHS( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT, 01781 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 01782 $ A( 1, 4 ), A( 1, 5 ), NMAX, A( 1, 6 ), 01783 $ A( 1, 7 ), DC( 1, 1 ), DC( 1, 2 ), A( 1, 8 ), 01784 $ A( 1, 9 ), A( 1, 10 ), A( 1, 11 ), A( 1, 12 ), 01785 $ DC( 1, 3 ), WORK, LWORK, RWORK, IWORK, LOGWRK, 01786 $ RESULT, INFO ) 01787 IF( INFO.NE.0 ) 01788 $ WRITE( NOUT, FMT = 9980 )'ZCHKHS', INFO 01789 270 CONTINUE 01790 * 01791 ELSE IF( LSAMEN( 3, C3, 'ZST' ) .OR. LSAMEN( 3, C3, 'SEP' ) ) THEN 01792 * 01793 * ---------------------------------- 01794 * SEP: Symmetric Eigenvalue Problem 01795 * ---------------------------------- 01796 * Vary the parameters 01797 * NB = block size 01798 * NBMIN = minimum block size 01799 * NX = crossover point 01800 * 01801 MAXTYP = 21 01802 NTYPES = MIN( MAXTYP, NTYPES ) 01803 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 01804 CALL XLAENV( 1, 1 ) 01805 CALL XLAENV( 9, 25 ) 01806 IF( TSTERR ) 01807 $ CALL ZERRST( 'ZST', NOUT ) 01808 DO 290 I = 1, NPARMS 01809 CALL XLAENV( 1, NBVAL( I ) ) 01810 CALL XLAENV( 2, NBMIN( I ) ) 01811 CALL XLAENV( 3, NXVAL( I ) ) 01812 * 01813 IF( NEWSD.EQ.0 ) THEN 01814 DO 280 K = 1, 4 01815 ISEED( K ) = IOLDSD( K ) 01816 280 CONTINUE 01817 END IF 01818 WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ), 01819 $ NXVAL( I ) 01820 IF( TSTCHK ) THEN 01821 CALL ZCHKST( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 01822 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), 01823 $ DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ), 01824 $ DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), 01825 $ DR( 1, 7 ), DR( 1, 8 ), DR( 1, 9 ), 01826 $ DR( 1, 10 ), DR( 1, 11 ), A( 1, 3 ), NMAX, 01827 $ A( 1, 4 ), A( 1, 5 ), DC( 1, 1 ), A( 1, 6 ), 01828 $ WORK, LWORK, RWORK, LWORK, IWORK, LIWORK, 01829 $ RESULT, INFO ) 01830 IF( INFO.NE.0 ) 01831 $ WRITE( NOUT, FMT = 9980 )'ZCHKST', INFO 01832 END IF 01833 IF( TSTDRV ) THEN 01834 CALL ZDRVST( NN, NVAL, 18, DOTYPE, ISEED, THRESH, NOUT, 01835 $ A( 1, 1 ), NMAX, DR( 1, 3 ), DR( 1, 4 ), 01836 $ DR( 1, 5 ), DR( 1, 8 ), DR( 1, 9 ), 01837 $ DR( 1, 10 ), A( 1, 2 ), NMAX, A( 1, 3 ), 01838 $ DC( 1, 1 ), A( 1, 4 ), WORK, LWORK, RWORK, 01839 $ LWORK, IWORK, LIWORK, RESULT, INFO ) 01840 IF( INFO.NE.0 ) 01841 $ WRITE( NOUT, FMT = 9980 )'ZDRVST', INFO 01842 END IF 01843 290 CONTINUE 01844 * 01845 ELSE IF( LSAMEN( 3, C3, 'ZSG' ) ) THEN 01846 * 01847 * ---------------------------------------------- 01848 * ZSG: Hermitian Generalized Eigenvalue Problem 01849 * ---------------------------------------------- 01850 * Vary the parameters 01851 * NB = block size 01852 * NBMIN = minimum block size 01853 * NX = crossover point 01854 * 01855 MAXTYP = 21 01856 NTYPES = MIN( MAXTYP, NTYPES ) 01857 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 01858 CALL XLAENV( 9, 25 ) 01859 DO 310 I = 1, NPARMS 01860 CALL XLAENV( 1, NBVAL( I ) ) 01861 CALL XLAENV( 2, NBMIN( I ) ) 01862 CALL XLAENV( 3, NXVAL( I ) ) 01863 * 01864 IF( NEWSD.EQ.0 ) THEN 01865 DO 300 K = 1, 4 01866 ISEED( K ) = IOLDSD( K ) 01867 300 CONTINUE 01868 END IF 01869 WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ), 01870 $ NXVAL( I ) 01871 IF( TSTCHK ) THEN 01872 CALL ZDRVSG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 01873 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX, 01874 $ DR( 1, 3 ), A( 1, 3 ), NMAX, A( 1, 4 ), 01875 $ A( 1, 5 ), A( 1, 6 ), A( 1, 7 ), WORK, 01876 $ LWORK, RWORK, LWORK, IWORK, LIWORK, RESULT, 01877 $ INFO ) 01878 IF( INFO.NE.0 ) 01879 $ WRITE( NOUT, FMT = 9980 )'ZDRVSG', INFO 01880 END IF 01881 310 CONTINUE 01882 * 01883 ELSE IF( LSAMEN( 3, C3, 'ZBD' ) .OR. LSAMEN( 3, C3, 'SVD' ) ) THEN 01884 * 01885 * ---------------------------------- 01886 * SVD: Singular Value Decomposition 01887 * ---------------------------------- 01888 * Vary the parameters 01889 * NB = block size 01890 * NBMIN = minimum block size 01891 * NX = crossover point 01892 * NRHS = number of right hand sides 01893 * 01894 MAXTYP = 16 01895 NTYPES = MIN( MAXTYP, NTYPES ) 01896 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 01897 CALL XLAENV( 9, 25 ) 01898 * 01899 * Test the error exits 01900 * 01901 CALL XLAENV( 1, 1 ) 01902 IF( TSTERR .AND. TSTCHK ) 01903 $ CALL ZERRBD( 'ZBD', NOUT ) 01904 IF( TSTERR .AND. TSTDRV ) 01905 $ CALL ZERRED( 'ZBD', NOUT ) 01906 * 01907 DO 330 I = 1, NPARMS 01908 NRHS = NSVAL( I ) 01909 CALL XLAENV( 1, NBVAL( I ) ) 01910 CALL XLAENV( 2, NBMIN( I ) ) 01911 CALL XLAENV( 3, NXVAL( I ) ) 01912 IF( NEWSD.EQ.0 ) THEN 01913 DO 320 K = 1, 4 01914 ISEED( K ) = IOLDSD( K ) 01915 320 CONTINUE 01916 END IF 01917 WRITE( NOUT, FMT = 9995 )C3, NBVAL( I ), NBMIN( I ), 01918 $ NXVAL( I ), NRHS 01919 IF( TSTCHK ) THEN 01920 CALL ZCHKBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, NRHS, ISEED, 01921 $ THRESH, A( 1, 1 ), NMAX, DR( 1, 1 ), 01922 $ DR( 1, 2 ), DR( 1, 3 ), DR( 1, 4 ), 01923 $ A( 1, 2 ), NMAX, A( 1, 3 ), A( 1, 4 ), 01924 $ A( 1, 5 ), NMAX, A( 1, 6 ), NMAX, A( 1, 7 ), 01925 $ A( 1, 8 ), WORK, LWORK, RWORK, NOUT, INFO ) 01926 IF( INFO.NE.0 ) 01927 $ WRITE( NOUT, FMT = 9980 )'ZCHKBD', INFO 01928 END IF 01929 IF( TSTDRV ) 01930 $ CALL ZDRVBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, ISEED, 01931 $ THRESH, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX, 01932 $ A( 1, 3 ), NMAX, A( 1, 4 ), A( 1, 5 ), 01933 $ A( 1, 6 ), DR( 1, 1 ), DR( 1, 2 ), 01934 $ DR( 1, 3 ), WORK, LWORK, RWORK, IWORK, NOUT, 01935 $ INFO ) 01936 330 CONTINUE 01937 * 01938 ELSE IF( LSAMEN( 3, C3, 'ZEV' ) ) THEN 01939 * 01940 * -------------------------------------------- 01941 * ZEV: Nonsymmetric Eigenvalue Problem Driver 01942 * ZGEEV (eigenvalues and eigenvectors) 01943 * -------------------------------------------- 01944 * 01945 MAXTYP = 21 01946 NTYPES = MIN( MAXTYP, NTYPES ) 01947 IF( NTYPES.LE.0 ) THEN 01948 WRITE( NOUT, FMT = 9990 )C3 01949 ELSE 01950 IF( TSTERR ) 01951 $ CALL ZERRED( C3, NOUT ) 01952 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 01953 CALL ZDRVEV( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT, 01954 $ A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ), 01955 $ DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX, 01956 $ A( 1, 5 ), NMAX, RESULT, WORK, LWORK, RWORK, 01957 $ IWORK, INFO ) 01958 IF( INFO.NE.0 ) 01959 $ WRITE( NOUT, FMT = 9980 )'ZGEEV', INFO 01960 END IF 01961 WRITE( NOUT, FMT = 9973 ) 01962 GO TO 10 01963 * 01964 ELSE IF( LSAMEN( 3, C3, 'ZES' ) ) THEN 01965 * 01966 * -------------------------------------------- 01967 * ZES: Nonsymmetric Eigenvalue Problem Driver 01968 * ZGEES (Schur form) 01969 * -------------------------------------------- 01970 * 01971 MAXTYP = 21 01972 NTYPES = MIN( MAXTYP, NTYPES ) 01973 IF( NTYPES.LE.0 ) THEN 01974 WRITE( NOUT, FMT = 9990 )C3 01975 ELSE 01976 IF( TSTERR ) 01977 $ CALL ZERRED( C3, NOUT ) 01978 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 01979 CALL ZDRVES( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT, 01980 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 01981 $ DC( 1, 1 ), DC( 1, 2 ), A( 1, 4 ), NMAX, 01982 $ RESULT, WORK, LWORK, RWORK, IWORK, LOGWRK, 01983 $ INFO ) 01984 IF( INFO.NE.0 ) 01985 $ WRITE( NOUT, FMT = 9980 )'ZGEES', INFO 01986 END IF 01987 WRITE( NOUT, FMT = 9973 ) 01988 GO TO 10 01989 * 01990 ELSE IF( LSAMEN( 3, C3, 'ZVX' ) ) THEN 01991 * 01992 * -------------------------------------------------------------- 01993 * ZVX: Nonsymmetric Eigenvalue Problem Expert Driver 01994 * ZGEEVX (eigenvalues, eigenvectors and condition numbers) 01995 * -------------------------------------------------------------- 01996 * 01997 MAXTYP = 21 01998 NTYPES = MIN( MAXTYP, NTYPES ) 01999 IF( NTYPES.LT.0 ) THEN 02000 WRITE( NOUT, FMT = 9990 )C3 02001 ELSE 02002 IF( TSTERR ) 02003 $ CALL ZERRED( C3, NOUT ) 02004 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02005 CALL ZDRVVX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN, 02006 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ), 02007 $ DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX, 02008 $ A( 1, 5 ), NMAX, DR( 1, 1 ), DR( 1, 2 ), 02009 $ DR( 1, 3 ), DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), 02010 $ DR( 1, 7 ), DR( 1, 8 ), RESULT, WORK, LWORK, 02011 $ RWORK, INFO ) 02012 IF( INFO.NE.0 ) 02013 $ WRITE( NOUT, FMT = 9980 )'ZGEEVX', INFO 02014 END IF 02015 WRITE( NOUT, FMT = 9973 ) 02016 GO TO 10 02017 * 02018 ELSE IF( LSAMEN( 3, C3, 'ZSX' ) ) THEN 02019 * 02020 * --------------------------------------------------- 02021 * ZSX: Nonsymmetric Eigenvalue Problem Expert Driver 02022 * ZGEESX (Schur form and condition numbers) 02023 * --------------------------------------------------- 02024 * 02025 MAXTYP = 21 02026 NTYPES = MIN( MAXTYP, NTYPES ) 02027 IF( NTYPES.LT.0 ) THEN 02028 WRITE( NOUT, FMT = 9990 )C3 02029 ELSE 02030 IF( TSTERR ) 02031 $ CALL ZERRED( C3, NOUT ) 02032 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02033 CALL ZDRVSX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN, 02034 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 02035 $ DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), A( 1, 4 ), 02036 $ NMAX, A( 1, 5 ), RESULT, WORK, LWORK, RWORK, 02037 $ LOGWRK, INFO ) 02038 IF( INFO.NE.0 ) 02039 $ WRITE( NOUT, FMT = 9980 )'ZGEESX', INFO 02040 END IF 02041 WRITE( NOUT, FMT = 9973 ) 02042 GO TO 10 02043 * 02044 ELSE IF( LSAMEN( 3, C3, 'ZGG' ) ) THEN 02045 * 02046 * ------------------------------------------------- 02047 * ZGG: Generalized Nonsymmetric Eigenvalue Problem 02048 * ------------------------------------------------- 02049 * Vary the parameters 02050 * NB = block size 02051 * NBMIN = minimum block size 02052 * NS = number of shifts 02053 * MAXB = minimum submatrix size 02054 * NBCOL = minimum column dimension for blocks 02055 * 02056 MAXTYP = 26 02057 NTYPES = MIN( MAXTYP, NTYPES ) 02058 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02059 IF( TSTCHK .AND. TSTERR ) 02060 $ CALL ZERRGG( C3, NOUT ) 02061 DO 350 I = 1, NPARMS 02062 CALL XLAENV( 1, NBVAL( I ) ) 02063 CALL XLAENV( 2, NBMIN( I ) ) 02064 CALL XLAENV( 4, NSVAL( I ) ) 02065 CALL XLAENV( 8, MXBVAL( I ) ) 02066 CALL XLAENV( 5, NBCOL( I ) ) 02067 * 02068 IF( NEWSD.EQ.0 ) THEN 02069 DO 340 K = 1, 4 02070 ISEED( K ) = IOLDSD( K ) 02071 340 CONTINUE 02072 END IF 02073 WRITE( NOUT, FMT = 9996 )C3, NBVAL( I ), NBMIN( I ), 02074 $ NSVAL( I ), MXBVAL( I ), NBCOL( I ) 02075 TSTDIF = .FALSE. 02076 THRSHN = 10.D0 02077 IF( TSTCHK ) THEN 02078 CALL ZCHKGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 02079 $ TSTDIF, THRSHN, NOUT, A( 1, 1 ), NMAX, 02080 $ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), 02081 $ A( 1, 6 ), A( 1, 7 ), A( 1, 8 ), A( 1, 9 ), 02082 $ NMAX, A( 1, 10 ), A( 1, 11 ), A( 1, 12 ), 02083 $ DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), 02084 $ DC( 1, 4 ), A( 1, 13 ), A( 1, 14 ), WORK, 02085 $ LWORK, RWORK, LOGWRK, RESULT, INFO ) 02086 IF( INFO.NE.0 ) 02087 $ WRITE( NOUT, FMT = 9980 )'ZCHKGG', INFO 02088 END IF 02089 CALL XLAENV( 1, 1 ) 02090 IF( TSTDRV ) THEN 02091 CALL ZDRVGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 02092 $ THRSHN, NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), 02093 $ A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), A( 1, 6 ), 02094 $ A( 1, 7 ), NMAX, A( 1, 8 ), DC( 1, 1 ), 02095 $ DC( 1, 2 ), DC( 1, 3 ), DC( 1, 4 ), 02096 $ A( 1, 8 ), A( 1, 9 ), WORK, LWORK, RWORK, 02097 $ RESULT, INFO ) 02098 IF( INFO.NE.0 ) 02099 $ WRITE( NOUT, FMT = 9980 )'ZDRVGG', INFO 02100 END IF 02101 350 CONTINUE 02102 * 02103 ELSE IF( LSAMEN( 3, C3, 'ZGS' ) ) THEN 02104 * 02105 * ------------------------------------------------- 02106 * ZGS: Generalized Nonsymmetric Eigenvalue Problem 02107 * ZGGES (Schur form) 02108 * ------------------------------------------------- 02109 * 02110 MAXTYP = 26 02111 NTYPES = MIN( MAXTYP, NTYPES ) 02112 IF( NTYPES.LE.0 ) THEN 02113 WRITE( NOUT, FMT = 9990 )C3 02114 ELSE 02115 IF( TSTERR ) 02116 $ CALL ZERRGG( C3, NOUT ) 02117 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02118 CALL ZDRGES( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT, 02119 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 02120 $ A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ), 02121 $ DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK, 02122 $ RESULT, LOGWRK, INFO ) 02123 * 02124 IF( INFO.NE.0 ) 02125 $ WRITE( NOUT, FMT = 9980 )'ZDRGES', INFO 02126 END IF 02127 WRITE( NOUT, FMT = 9973 ) 02128 GO TO 10 02129 * 02130 ELSE IF( ZGX ) THEN 02131 * 02132 * ------------------------------------------------- 02133 * ZGX Generalized Nonsymmetric Eigenvalue Problem 02134 * ZGGESX (Schur form and condition numbers) 02135 * ------------------------------------------------- 02136 * 02137 MAXTYP = 5 02138 NTYPES = MAXTYP 02139 IF( NN.LT.0 ) THEN 02140 WRITE( NOUT, FMT = 9990 )C3 02141 ELSE 02142 IF( TSTERR ) 02143 $ CALL ZERRGG( C3, NOUT ) 02144 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02145 CALL XLAENV( 5, 2 ) 02146 CALL ZDRGSX( NN, NCMAX, THRESH, NIN, NOUT, A( 1, 1 ), NMAX, 02147 $ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), 02148 $ A( 1, 6 ), DC( 1, 1 ), DC( 1, 2 ), C, 02149 $ NCMAX*NCMAX, S, WORK, LWORK, RWORK, IWORK, 02150 $ LIWORK, LOGWRK, INFO ) 02151 IF( INFO.NE.0 ) 02152 $ WRITE( NOUT, FMT = 9980 )'ZDRGSX', INFO 02153 END IF 02154 WRITE( NOUT, FMT = 9973 ) 02155 GO TO 10 02156 * 02157 ELSE IF( LSAMEN( 3, C3, 'ZGV' ) ) THEN 02158 * 02159 * ------------------------------------------------- 02160 * ZGV: Generalized Nonsymmetric Eigenvalue Problem 02161 * ZGGEV (Eigenvalue/vector form) 02162 * ------------------------------------------------- 02163 * 02164 MAXTYP = 26 02165 NTYPES = MIN( MAXTYP, NTYPES ) 02166 IF( NTYPES.LE.0 ) THEN 02167 WRITE( NOUT, FMT = 9990 )C3 02168 ELSE 02169 IF( TSTERR ) 02170 $ CALL ZERRGG( C3, NOUT ) 02171 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02172 CALL ZDRGEV( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT, 02173 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 02174 $ A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ), 02175 $ A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ), 02176 $ DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK, 02177 $ RESULT, INFO ) 02178 IF( INFO.NE.0 ) 02179 $ WRITE( NOUT, FMT = 9980 )'ZDRGEV', INFO 02180 END IF 02181 WRITE( NOUT, FMT = 9973 ) 02182 GO TO 10 02183 * 02184 ELSE IF( ZXV ) THEN 02185 * 02186 * ------------------------------------------------- 02187 * ZXV: Generalized Nonsymmetric Eigenvalue Problem 02188 * ZGGEVX (eigenvalue/vector with condition numbers) 02189 * ------------------------------------------------- 02190 * 02191 MAXTYP = 2 02192 NTYPES = MAXTYP 02193 IF( NN.LT.0 ) THEN 02194 WRITE( NOUT, FMT = 9990 )C3 02195 ELSE 02196 IF( TSTERR ) 02197 $ CALL ZERRGG( C3, NOUT ) 02198 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02199 CALL ZDRGVX( NN, THRESH, NIN, NOUT, A( 1, 1 ), NMAX, 02200 $ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), DC( 1, 1 ), 02201 $ DC( 1, 2 ), A( 1, 5 ), A( 1, 6 ), IWORK( 1 ), 02202 $ IWORK( 2 ), DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ), 02203 $ DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), WORK, 02204 $ LWORK, RWORK, IWORK( 3 ), LIWORK-2, RESULT, 02205 $ LOGWRK, INFO ) 02206 * 02207 IF( INFO.NE.0 ) 02208 $ WRITE( NOUT, FMT = 9980 )'ZDRGVX', INFO 02209 END IF 02210 WRITE( NOUT, FMT = 9973 ) 02211 GO TO 10 02212 * 02213 ELSE IF( LSAMEN( 3, C3, 'ZHB' ) ) THEN 02214 * 02215 * ------------------------------ 02216 * ZHB: Hermitian Band Reduction 02217 * ------------------------------ 02218 * 02219 MAXTYP = 15 02220 NTYPES = MIN( MAXTYP, NTYPES ) 02221 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02222 IF( TSTERR ) 02223 $ CALL ZERRST( 'ZHB', NOUT ) 02224 CALL ZCHKHB( NN, NVAL, NK, KVAL, MAXTYP, DOTYPE, ISEED, THRESH, 02225 $ NOUT, A( 1, 1 ), NMAX, DR( 1, 1 ), DR( 1, 2 ), 02226 $ A( 1, 2 ), NMAX, WORK, LWORK, RWORK, RESULT, 02227 $ INFO ) 02228 IF( INFO.NE.0 ) 02229 $ WRITE( NOUT, FMT = 9980 )'ZCHKHB', INFO 02230 * 02231 ELSE IF( LSAMEN( 3, C3, 'ZBB' ) ) THEN 02232 * 02233 * ------------------------------ 02234 * ZBB: General Band Reduction 02235 * ------------------------------ 02236 * 02237 MAXTYP = 15 02238 NTYPES = MIN( MAXTYP, NTYPES ) 02239 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 02240 DO 370 I = 1, NPARMS 02241 NRHS = NSVAL( I ) 02242 * 02243 IF( NEWSD.EQ.0 ) THEN 02244 DO 360 K = 1, 4 02245 ISEED( K ) = IOLDSD( K ) 02246 360 CONTINUE 02247 END IF 02248 WRITE( NOUT, FMT = 9966 )C3, NRHS 02249 CALL ZCHKBB( NN, MVAL, NVAL, NK, KVAL, MAXTYP, DOTYPE, NRHS, 02250 $ ISEED, THRESH, NOUT, A( 1, 1 ), NMAX, 02251 $ A( 1, 2 ), 2*NMAX, DR( 1, 1 ), DR( 1, 2 ), 02252 $ A( 1, 4 ), NMAX, A( 1, 5 ), NMAX, A( 1, 6 ), 02253 $ NMAX, A( 1, 7 ), WORK, LWORK, RWORK, RESULT, 02254 $ INFO ) 02255 IF( INFO.NE.0 ) 02256 $ WRITE( NOUT, FMT = 9980 )'ZCHKBB', INFO 02257 370 CONTINUE 02258 * 02259 ELSE IF( LSAMEN( 3, C3, 'GLM' ) ) THEN 02260 * 02261 * ----------------------------------------- 02262 * GLM: Generalized Linear Regression Model 02263 * ----------------------------------------- 02264 * 02265 CALL XLAENV( 1, 1 ) 02266 IF( TSTERR ) 02267 $ CALL ZERRGG( 'GLM', NOUT ) 02268 CALL ZCKGLM( NN, NVAL, MVAL, PVAL, NTYPES, ISEED, THRESH, NMAX, 02269 $ A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X, 02270 $ WORK, DR( 1, 1 ), NIN, NOUT, INFO ) 02271 IF( INFO.NE.0 ) 02272 $ WRITE( NOUT, FMT = 9980 )'ZCKGLM', INFO 02273 * 02274 ELSE IF( LSAMEN( 3, C3, 'GQR' ) ) THEN 02275 * 02276 * ------------------------------------------ 02277 * GQR: Generalized QR and RQ factorizations 02278 * ------------------------------------------ 02279 * 02280 CALL XLAENV( 1, 1 ) 02281 IF( TSTERR ) 02282 $ CALL ZERRGG( 'GQR', NOUT ) 02283 CALL ZCKGQR( NN, MVAL, NN, PVAL, NN, NVAL, NTYPES, ISEED, 02284 $ THRESH, NMAX, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), 02285 $ A( 1, 4 ), TAUA, B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), 02286 $ B( 1, 4 ), B( 1, 5 ), TAUB, WORK, DR( 1, 1 ), NIN, 02287 $ NOUT, INFO ) 02288 IF( INFO.NE.0 ) 02289 $ WRITE( NOUT, FMT = 9980 )'ZCKGQR', INFO 02290 * 02291 ELSE IF( LSAMEN( 3, C3, 'GSV' ) ) THEN 02292 * 02293 * ---------------------------------------------- 02294 * GSV: Generalized Singular Value Decomposition 02295 * ---------------------------------------------- 02296 * 02297 IF( TSTERR ) 02298 $ CALL ZERRGG( 'GSV', NOUT ) 02299 CALL ZCKGSV( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX, 02300 $ A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), 02301 $ A( 1, 3 ), B( 1, 3 ), A( 1, 4 ), ALPHA, BETA, 02302 $ B( 1, 4 ), IWORK, WORK, DR( 1, 1 ), NIN, NOUT, 02303 $ INFO ) 02304 IF( INFO.NE.0 ) 02305 $ WRITE( NOUT, FMT = 9980 )'ZCKGSV', INFO 02306 * 02307 ELSE IF( LSAMEN( 3, C3, 'CSD' ) ) THEN 02308 * 02309 * ---------------------------------------------- 02310 * CSD: CS Decomposition 02311 * ---------------------------------------------- 02312 * 02313 IF( TSTERR ) 02314 $ CALL ZERRGG( 'CSD', NOUT ) 02315 CALL ZCKCSD( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX, 02316 $ A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), 02317 $ A( 1, 5 ), A( 1, 6 ), A( 1, 7 ), IWORK, WORK, 02318 $ DR( 1, 1 ), NIN, NOUT, INFO ) 02319 IF( INFO.NE.0 ) 02320 $ WRITE( NOUT, FMT = 9980 )'ZCKCSD', INFO 02321 * 02322 ELSE IF( LSAMEN( 3, C3, 'LSE' ) ) THEN 02323 * 02324 * -------------------------------------- 02325 * LSE: Constrained Linear Least Squares 02326 * -------------------------------------- 02327 * 02328 CALL XLAENV( 1, 1 ) 02329 IF( TSTERR ) 02330 $ CALL ZERRGG( 'LSE', NOUT ) 02331 CALL ZCKLSE( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX, 02332 $ A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X, 02333 $ WORK, DR( 1, 1 ), NIN, NOUT, INFO ) 02334 IF( INFO.NE.0 ) 02335 $ WRITE( NOUT, FMT = 9980 )'ZCKLSE', INFO 02336 ELSE 02337 WRITE( NOUT, FMT = * ) 02338 WRITE( NOUT, FMT = * ) 02339 WRITE( NOUT, FMT = 9992 )C3 02340 END IF 02341 IF( .NOT.( ZGX .OR. ZXV ) ) 02342 $ GO TO 190 02343 380 CONTINUE 02344 WRITE( NOUT, FMT = 9994 ) 02345 S2 = DSECND( ) 02346 WRITE( NOUT, FMT = 9993 )S2 - S1 02347 * 02348 9999 FORMAT( / ' Execution not attempted due to input errors' ) 02349 9998 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4, 02350 $ ', NS =', I4, ', MAXB =', I4 ) 02351 9997 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4 ) 02352 9996 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NS =', I4, 02353 $ ', MAXB =', I4, ', NBCOL =', I4 ) 02354 9995 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4, 02355 $ ', NRHS =', I4 ) 02356 9994 FORMAT( / / ' End of tests' ) 02357 9993 FORMAT( ' Total time used = ', F12.2, ' seconds', / ) 02358 9992 FORMAT( 1X, A3, ': Unrecognized path name' ) 02359 9991 FORMAT( / / ' *** Invalid integer value in column ', I2, 02360 $ ' of input', ' line:', / A79 ) 02361 9990 FORMAT( / / 1X, A3, ' routines were not tested' ) 02362 9989 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be >=', 02363 $ I6 ) 02364 9988 FORMAT( ' Invalid input value: ', A, '=', I6, '; must be <=', 02365 $ I6 ) 02366 9987 FORMAT( ' Tests of the Nonsymmetric Eigenvalue Problem routines' ) 02367 9986 FORMAT( ' Tests of the Hermitian Eigenvalue Problem routines' ) 02368 9985 FORMAT( ' Tests of the Singular Value Decomposition routines' ) 02369 9984 FORMAT( / ' The following parameter values will be used:' ) 02370 9983 FORMAT( 4X, A, 10I6, / 10X, 10I6 ) 02371 9982 FORMAT( / ' Routines pass computational tests if test ratio is ', 02372 $ 'less than', F8.2, / ) 02373 9981 FORMAT( ' Relative machine ', A, ' is taken to be', D16.6 ) 02374 9980 FORMAT( ' *** Error code from ', A, ' = ', I4 ) 02375 9979 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver', 02376 $ / ' ZGEEV (eigenvalues and eigevectors)' ) 02377 9978 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver', 02378 $ / ' ZGEES (Schur form)' ) 02379 9977 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert', 02380 $ ' Driver', / ' ZGEEVX (eigenvalues, eigenvectors and', 02381 $ ' condition numbers)' ) 02382 9976 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert', 02383 $ ' Driver', / ' ZGEESX (Schur form and condition', 02384 $ ' numbers)' ) 02385 9975 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 02386 $ 'Problem routines' ) 02387 9974 FORMAT( ' Tests of ZHBTRD', / ' (reduction of a Hermitian band ', 02388 $ 'matrix to real tridiagonal form)' ) 02389 9973 FORMAT( / 1X, 71( '-' ) ) 02390 9972 FORMAT( / ' LAPACK VERSION ', I1, '.', I1, '.', I1 ) 02391 9971 FORMAT( / ' Tests of the Generalized Linear Regression Model ', 02392 $ 'routines' ) 02393 9970 FORMAT( / ' Tests of the Generalized QR and RQ routines' ) 02394 9969 FORMAT( / ' Tests of the Generalized Singular Value', 02395 $ ' Decomposition routines' ) 02396 9968 FORMAT( / ' Tests of the Linear Least Squares routines' ) 02397 9967 FORMAT( ' Tests of ZGBBRD', / ' (reduction of a general band ', 02398 $ 'matrix to real bidiagonal form)' ) 02399 9966 FORMAT( / / 1X, A3, ': NRHS =', I4 ) 02400 9965 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 02401 $ 'Problem Expert Driver ZGGESX' ) 02402 9964 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 02403 $ 'Problem Driver ZGGES' ) 02404 9963 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 02405 $ 'Problem Driver ZGGEV' ) 02406 9962 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 02407 $ 'Problem Expert Driver ZGGEVX' ) 02408 9961 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4, 02409 $ ', INMIN=', I4, 02410 $ ', INWIN =', I4, ', INIBL =', I4, ', ISHFTS =', I4, 02411 $ ', IACC22 =', I4) 02412 9960 FORMAT( / ' Tests of the CS Decomposition routines' ) 02413 * 02414 * End of ZCHKEE 02415 * 02416 END
1.7.3 
