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