1 PROGRAM ZCHKEE 2* 3* -- LAPACK test routine (version 3.0) -- 4* Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., 5* Courant Institute, Argonne National Lab, and Rice University 6* June 30, 1999 7* 8* Purpose 9* ======= 10* 11* ZCHKEE tests the COMPLEX*16 LAPACK subroutines for the matrix 12* eigenvalue problem. The test paths in this version are 13* 14* NEP (Nonsymmetric Eigenvalue Problem): 15* Test ZGEHRD, ZUNGHR, ZHSEQR, ZTREVC, ZHSEIN, and ZUNMHR 16* 17* SEP (Hermitian Eigenvalue Problem): 18* Test ZHETRD, ZUNGTR, ZSTEQR, ZSTERF, ZSTEIN, ZSTEDC, 19* and drivers ZHEEV(X), ZHBEV(X), ZHPEV(X), 20* ZHEEVD, ZHBEVD, ZHPEVD 21* 22* SVD (Singular Value Decomposition): 23* Test ZGEBRD, ZUNGBR, and ZBDSQR 24* and the drivers ZGESVD, ZGESDD 25* 26* ZEV (Nonsymmetric Eigenvalue/eigenvector Driver): 27* Test ZGEEV 28* 29* ZES (Nonsymmetric Schur form Driver): 30* Test ZGEES 31* 32* ZVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver): 33* Test ZGEEVX 34* 35* ZSX (Nonsymmetric Schur form Expert Driver): 36* Test ZGEESX 37* 38* ZGG (Generalized Nonsymmetric Eigenvalue Problem): 39* Test ZGGHRD, ZGGBAL, ZGGBAK, ZHGEQZ, and ZTGEVC 40* and the driver routines ZGEGS and ZGEGV 41* 42* ZGS (Generalized Nonsymmetric Schur form Driver): 43* Test ZGGES 44* 45* ZGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver): 46* Test ZGGEV 47* 48* ZGX (Generalized Nonsymmetric Schur form Expert Driver): 49* Test ZGGESX 50* 51* ZXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver): 52* Test ZGGEVX 53* 54* ZSG (Hermitian Generalized Eigenvalue Problem): 55* Test ZHEGST, ZHEGV, ZHEGVD, ZHEGVX, ZHPGST, ZHPGV, ZHPGVD, 56* ZHPGVX, ZHBGST, ZHBGV, ZHBGVD, and ZHBGVX 57* 58* ZHB (Hermitian Band Eigenvalue Problem): 59* Test ZHBTRD 60* 61* ZBB (Band Singular Value Decomposition): 62* Test ZGBBRD 63* 64* ZEC (Eigencondition estimation): 65* Test ZTRSYL, ZTREXC, ZTRSNA, and ZTRSEN 66* 67* ZBL (Balancing a general matrix) 68* Test ZGEBAL 69* 70* ZBK (Back transformation on a balanced matrix) 71* Test ZGEBAK 72* 73* ZGL (Balancing a matrix pair) 74* Test ZGGBAL 75* 76* ZGK (Back transformation on a matrix pair) 77* Test ZGGBAK 78* 79* GLM (Generalized Linear Regression Model): 80* Tests ZGGGLM 81* 82* GQR (Generalized QR and RQ factorizations): 83* Tests ZGGQRF and ZGGRQF 84* 85* GSV (Generalized Singular Value Decomposition): 86* Tests ZGGSVD, ZGGSVP, ZTGSJA, ZLAGS2, ZLAPLL, and ZLAPMT 87* 88* LSE (Constrained Linear Least Squares): 89* Tests ZGGLSE 90* 91* Each test path has a different set of inputs, but the data sets for 92* the driver routines xEV, xES, xVX, and xSX can be concatenated in a 93* single input file. The first line of input should contain one of the 94* 3-character path names in columns 1-3. The number of remaining lines 95* depends on what is found on the first line. 96* 97* The number of matrix types used in testing is often controllable from 98* the input file. The number of matrix types for each path, and the 99* test routine that describes them, is as follows: 100* 101* Path name(s) Types Test routine 102* 103* ZHS or NEP 21 ZCHKHS 104* ZST or SEP 21 ZCHKST (routines) 105* 18 ZDRVST (drivers) 106* ZBD or SVD 16 ZCHKBD (routines) 107* 5 ZDRVBD (drivers) 108* ZEV 21 ZDRVEV 109* ZES 21 ZDRVES 110* ZVX 21 ZDRVVX 111* ZSX 21 ZDRVSX 112* ZGG 26 ZCHKGG (routines) 113* 26 ZDRVGG (drivers) 114* ZGS 26 ZDRGES 115* ZGX 5 ZDRGSX 116* ZGV 26 ZDRGEV 117* ZXV 2 ZDRGVX 118* ZSG 21 ZDRVSG 119* ZHB 15 ZCHKHB 120* ZBB 15 ZCHKBB 121* ZEC - ZCHKEC 122* ZBL - ZCHKBL 123* ZBK - ZCHKBK 124* ZGL - ZCHKGL 125* ZGK - ZCHKGK 126* GLM 8 ZCKGLM 127* GQR 8 ZCKGQR 128* GSV 8 ZCKGSV 129* LSE 8 ZCKLSE 130* 131*----------------------------------------------------------------------- 132* 133* NEP input file: 134* 135* line 2: NN, INTEGER 136* Number of values of N. 137* 138* line 3: NVAL, INTEGER array, dimension (NN) 139* The values for the matrix dimension N. 140* 141* line 4: NPARMS, INTEGER 142* Number of values of the parameters NB, NBMIN, NX, NS, and 143* MAXB. 144* 145* line 5: NBVAL, INTEGER array, dimension (NPARMS) 146* The values for the blocksize NB. 147* 148* line 6: NBMIN, INTEGER array, dimension (NPARMS) 149* The values for the minimum blocksize NBMIN. 150* 151* line 7: NXVAL, INTEGER array, dimension (NPARMS) 152* The values for the crossover point NX. 153* 154* line 8: NSVAL, INTEGER array, dimension (NPARMS) 155* The values for the number of shifts. 156* 157* line 9: MXBVAL, INTEGER array, dimension (NPARMS) 158* The values for MAXB, used in determining minimum blocksize. 159* 160* line 10: THRESH 161* Threshold value for the test ratios. Information will be 162* printed about each test for which the test ratio is greater 163* than or equal to the threshold. To have all of the test 164* ratios printed, use THRESH = 0.0 . 165* 166* line 11: NEWSD, INTEGER 167* A code indicating how to set the random number seed. 168* = 0: Set the seed to a default value before each run 169* = 1: Initialize the seed to a default value only before the 170* first run 171* = 2: Like 1, but use the seed values on the next line 172* 173* If line 11 was 2: 174* 175* line 12: INTEGER array, dimension (4) 176* Four integer values for the random number seed. 177* 178* lines 12-EOF: The remaining lines occur in sets of 1 or 2 and allow 179* the user to specify the matrix types. Each line contains 180* a 3-character path name in columns 1-3, and the number 181* of matrix types must be the first nonblank item in columns 182* 4-80. If the number of matrix types is at least 1 but is 183* less than the maximum number of possible types, a second 184* line will be read to get the numbers of the matrix types to 185* be used. For example, 186* NEP 21 187* requests all of the matrix types for the nonsymmetric 188* eigenvalue problem, while 189* NEP 4 190* 9 10 11 12 191* requests only matrices of type 9, 10, 11, and 12. 192* 193* The valid 3-character path names are 'NEP' or 'ZHS' for the 194* nonsymmetric eigenvalue routines. 195* 196*----------------------------------------------------------------------- 197* 198* SEP or ZSG input file: 199* 200* line 2: NN, INTEGER 201* Number of values of N. 202* 203* line 3: NVAL, INTEGER array, dimension (NN) 204* The values for the matrix dimension N. 205* 206* line 4: NPARMS, INTEGER 207* Number of values of the parameters NB, NBMIN, and NX. 208* 209* line 5: NBVAL, INTEGER array, dimension (NPARMS) 210* The values for the blocksize NB. 211* 212* line 6: NBMIN, INTEGER array, dimension (NPARMS) 213* The values for the minimum blocksize NBMIN. 214* 215* line 7: NXVAL, INTEGER array, dimension (NPARMS) 216* The values for the crossover point NX. 217* 218* line 8: THRESH 219* Threshold value for the test ratios. Information will be 220* printed about each test for which the test ratio is greater 221* than or equal to the threshold. 222* 223* line 9: TSTCHK, LOGICAL 224* Flag indicating whether or not to test the LAPACK routines. 225* 226* line 10: TSTDRV, LOGICAL 227* Flag indicating whether or not to test the driver routines. 228* 229* line 11: TSTERR, LOGICAL 230* Flag indicating whether or not to test the error exits for 231* the LAPACK routines and driver routines. 232* 233* line 12: NEWSD, INTEGER 234* A code indicating how to set the random number seed. 235* = 0: Set the seed to a default value before each run 236* = 1: Initialize the seed to a default value only before the 237* first run 238* = 2: Like 1, but use the seed values on the next line 239* 240* If line 12 was 2: 241* 242* line 13: INTEGER array, dimension (4) 243* Four integer values for the random number seed. 244* 245* lines 13-EOF: Lines specifying matrix types, as for NEP. 246* The valid 3-character path names are 'SEP' or 'ZST' for the 247* Hermitian eigenvalue routines and driver routines, and 248* 'ZSG' for the routines for the Hermitian generalized 249* eigenvalue problem. 250* 251*----------------------------------------------------------------------- 252* 253* SVD input file: 254* 255* line 2: NN, INTEGER 256* Number of values of M and N. 257* 258* line 3: MVAL, INTEGER array, dimension (NN) 259* The values for the matrix row dimension M. 260* 261* line 4: NVAL, INTEGER array, dimension (NN) 262* The values for the matrix column dimension N. 263* 264* line 5: NPARMS, INTEGER 265* Number of values of the parameter NB, NBMIN, NX, and NRHS. 266* 267* line 6: NBVAL, INTEGER array, dimension (NPARMS) 268* The values for the blocksize NB. 269* 270* line 7: NBMIN, INTEGER array, dimension (NPARMS) 271* The values for the minimum blocksize NBMIN. 272* 273* line 8: NXVAL, INTEGER array, dimension (NPARMS) 274* The values for the crossover point NX. 275* 276* line 9: NSVAL, INTEGER array, dimension (NPARMS) 277* The values for the number of right hand sides NRHS. 278* 279* line 10: THRESH 280* Threshold value for the test ratios. Information will be 281* printed about each test for which the test ratio is greater 282* than or equal to the threshold. 283* 284* line 11: TSTCHK, LOGICAL 285* Flag indicating whether or not to test the LAPACK routines. 286* 287* line 12: TSTDRV, LOGICAL 288* Flag indicating whether or not to test the driver routines. 289* 290* line 13: TSTERR, LOGICAL 291* Flag indicating whether or not to test the error exits for 292* the LAPACK routines and driver routines. 293* 294* line 14: NEWSD, INTEGER 295* A code indicating how to set the random number seed. 296* = 0: Set the seed to a default value before each run 297* = 1: Initialize the seed to a default value only before the 298* first run 299* = 2: Like 1, but use the seed values on the next line 300* 301* If line 14 was 2: 302* 303* line 15: INTEGER array, dimension (4) 304* Four integer values for the random number seed. 305* 306* lines 15-EOF: Lines specifying matrix types, as for NEP. 307* The 3-character path names are 'SVD' or 'ZBD' for both the 308* SVD routines and the SVD driver routines. 309* 310*----------------------------------------------------------------------- 311* 312* ZEV and ZES data files: 313* 314* line 1: 'ZEV' or 'ZES' in columns 1 to 3. 315* 316* line 2: NSIZES, INTEGER 317* Number of sizes of matrices to use. Should be at least 0 318* and at most 20. If NSIZES = 0, no testing is done 319* (although the remaining 3 lines are still read). 320* 321* line 3: NN, INTEGER array, dimension(NSIZES) 322* Dimensions of matrices to be tested. 323* 324* line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 325* These integer parameters determine how blocking is done 326* (see ILAENV for details) 327* NB : block size 328* NBMIN : minimum block size 329* NX : minimum dimension for blocking 330* NS : number of shifts in xHSEQR 331* NBCOL : minimum column dimension for blocking 332* 333* line 5: THRESH, REAL 334* The test threshold against which computed residuals are 335* compared. Should generally be in the range from 10. to 20. 336* If it is 0., all test case data will be printed. 337* 338* line 6: NEWSD, INTEGER 339* A code indicating how to set the random number seed. 340* = 0: Set the seed to a default value before each run 341* = 1: Initialize the seed to a default value only before the 342* first run 343* = 2: Like 1, but use the seed values on the next line 344* 345* If line 6 was 2: 346* 347* line 7: INTEGER array, dimension (4) 348* Four integer values for the random number seed. 349* 350* lines 8 and following: Lines specifying matrix types, as for NEP. 351* The 3-character path name is 'ZEV' to test CGEEV, or 352* 'ZES' to test CGEES. 353* 354*----------------------------------------------------------------------- 355* 356* The ZVX data has two parts. The first part is identical to ZEV, 357* and the second part consists of test matrices with precomputed 358* solutions. 359* 360* line 1: 'ZVX' in columns 1-3. 361* 362* line 2: NSIZES, INTEGER 363* If NSIZES = 0, no testing of randomly generated examples 364* is done, but any precomputed examples are tested. 365* 366* line 3: NN, INTEGER array, dimension(NSIZES) 367* 368* line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 369* 370* line 5: THRESH, REAL 371* 372* line 6: NEWSD, INTEGER 373* 374* If line 6 was 2: 375* 376* line 7: INTEGER array, dimension (4) 377* 378* lines 8 and following: The first line contains 'ZVX' in columns 1-3 379* followed by the number of matrix types, possibly with 380* a second line to specify certain matrix types. 381* If the number of matrix types = 0, no testing of randomly 382* generated examples is done, but any precomputed examples 383* are tested. 384* 385* remaining lines : Each matrix is stored on 1+N+N**2 lines, where N is 386* its dimension. The first line contains the dimension N and 387* ISRT (two integers). ISRT indicates whether the last N lines 388* are sorted by increasing real part of the eigenvalue 389* (ISRT=0) or by increasing imaginary part (ISRT=1). The next 390* N**2 lines contain the matrix rowwise, one entry per line. 391* The last N lines correspond to each eigenvalue. Each of 392* these last N lines contains 4 real values: the real part of 393* the eigenvalues, the imaginary part of the eigenvalue, the 394* reciprocal condition number of the eigenvalues, and the 395* reciprocal condition number of the vector eigenvector. The 396* end of data is indicated by dimension N=0. Even if no data 397* is to be tested, there must be at least one line containing 398* N=0. 399* 400*----------------------------------------------------------------------- 401* 402* The ZSX data is like ZVX. The first part is identical to ZEV, and the 403* second part consists of test matrices with precomputed solutions. 404* 405* line 1: 'ZSX' in columns 1-3. 406* 407* line 2: NSIZES, INTEGER 408* If NSIZES = 0, no testing of randomly generated examples 409* is done, but any precomputed examples are tested. 410* 411* line 3: NN, INTEGER array, dimension(NSIZES) 412* 413* line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 414* 415* line 5: THRESH, REAL 416* 417* line 6: NEWSD, INTEGER 418* 419* If line 6 was 2: 420* 421* line 7: INTEGER array, dimension (4) 422* 423* lines 8 and following: The first line contains 'ZSX' in columns 1-3 424* followed by the number of matrix types, possibly with 425* a second line to specify certain matrix types. 426* If the number of matrix types = 0, no testing of randomly 427* generated examples is done, but any precomputed examples 428* are tested. 429* 430* remaining lines : Each matrix is stored on 3+N**2 lines, where N is 431* its dimension. The first line contains the dimension N, the 432* dimension M of an invariant subspace, and ISRT. The second 433* line contains M integers, identifying the eigenvalues in the 434* invariant subspace (by their position in a list of 435* eigenvalues ordered by increasing real part (if ISRT=0) or 436* by increasing imaginary part (if ISRT=1)). The next N**2 437* lines contain the matrix rowwise. The last line contains the 438* reciprocal condition number for the average of the selected 439* eigenvalues, and the reciprocal condition number for the 440* corresponding right invariant subspace. The end of data in 441* indicated by a line containing N=0, M=0, and ISRT = 0. Even 442* if no data is to be tested, there must be at least one line 443* containing N=0, M=0 and ISRT=0. 444* 445*----------------------------------------------------------------------- 446* 447* ZGG input file: 448* 449* line 2: NN, INTEGER 450* Number of values of N. 451* 452* line 3: NVAL, INTEGER array, dimension (NN) 453* The values for the matrix dimension N. 454* 455* line 4: NPARMS, INTEGER 456* Number of values of the parameters NB, NBMIN, NBCOL, NS, and 457* MAXB. 458* 459* line 5: NBVAL, INTEGER array, dimension (NPARMS) 460* The values for the blocksize NB. 461* 462* line 6: NBMIN, INTEGER array, dimension (NPARMS) 463* The values for NBMIN, the minimum row dimension for blocks. 464* 465* line 7: NSVAL, INTEGER array, dimension (NPARMS) 466* The values for the number of shifts. 467* 468* line 8: MXBVAL, INTEGER array, dimension (NPARMS) 469* The values for MAXB, used in determining minimum blocksize. 470* 471* line 9: NBCOL, INTEGER array, dimension (NPARMS) 472* The values for NBCOL, the minimum column dimension for 473* blocks. 474* 475* line 10: THRESH 476* Threshold value for the test ratios. Information will be 477* printed about each test for which the test ratio is greater 478* than or equal to the threshold. 479* 480* line 11: TSTCHK, LOGICAL 481* Flag indicating whether or not to test the LAPACK routines. 482* 483* line 12: TSTDRV, LOGICAL 484* Flag indicating whether or not to test the driver routines. 485* 486* line 13: TSTERR, LOGICAL 487* Flag indicating whether or not to test the error exits for 488* the LAPACK routines and driver routines. 489* 490* line 14: NEWSD, INTEGER 491* A code indicating how to set the random number seed. 492* = 0: Set the seed to a default value before each run 493* = 1: Initialize the seed to a default value only before the 494* first run 495* = 2: Like 1, but use the seed values on the next line 496* 497* If line 14 was 2: 498* 499* line 15: INTEGER array, dimension (4) 500* Four integer values for the random number seed. 501* 502* lines 16-EOF: Lines specifying matrix types, as for NEP. 503* The 3-character path name is 'ZGG' for the generalized 504* eigenvalue problem routines and driver routines. 505* 506*----------------------------------------------------------------------- 507* 508* ZGS and ZGV input files: 509* 510* line 1: 'ZGS' or 'ZGV' in columns 1 to 3. 511* 512* line 2: NN, INTEGER 513* Number of values of N. 514* 515* line 3: NVAL, INTEGER array, dimension(NN) 516* Dimensions of matrices to be tested. 517* 518* line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs 519* These integer parameters determine how blocking is done 520* (see ILAENV for details) 521* NB : block size 522* NBMIN : minimum block size 523* NX : minimum dimension for blocking 524* NS : number of shifts in xHGEQR 525* NBCOL : minimum column dimension for blocking 526* 527* line 5: THRESH, REAL 528* The test threshold against which computed residuals are 529* compared. Should generally be in the range from 10. to 20. 530* If it is 0., all test case data will be printed. 531* 532* line 6: TSTERR, LOGICAL 533* Flag indicating whether or not to test the error exits. 534* 535* line 7: NEWSD, INTEGER 536* A code indicating how to set the random number seed. 537* = 0: Set the seed to a default value before each run 538* = 1: Initialize the seed to a default value only before the 539* first run 540* = 2: Like 1, but use the seed values on the next line 541* 542* If line 17 was 2: 543* 544* line 7: INTEGER array, dimension (4) 545* Four integer values for the random number seed. 546* 547* lines 7-EOF: Lines specifying matrix types, as for NEP. 548* The 3-character path name is 'ZGS' for the generalized 549* eigenvalue problem routines and driver routines. 550* 551*----------------------------------------------------------------------- 552* 553* ZGX input file: 554* line 1: 'ZGX' in columns 1 to 3. 555* 556* line 2: N, INTEGER 557* Value of N. 558* 559* line 3: NB, NBMIN, NX, NS, NBCOL, INTEGERs 560* These integer parameters determine how blocking is done 561* (see ILAENV for details) 562* NB : block size 563* NBMIN : minimum block size 564* NX : minimum dimension for blocking 565* NS : number of shifts in xHGEQR 566* NBCOL : minimum column dimension for blocking 567* 568* line 4: THRESH, REAL 569* The test threshold against which computed residuals are 570* compared. Should generally be in the range from 10. to 20. 571* Information will be printed about each test for which the 572* test ratio is greater than or equal to the threshold. 573* 574* line 5: TSTERR, LOGICAL 575* Flag indicating whether or not to test the error exits for 576* the LAPACK routines and driver routines. 577* 578* line 6: NEWSD, INTEGER 579* A code indicating how to set the random number seed. 580* = 0: Set the seed to a default value before each run 581* = 1: Initialize the seed to a default value only before the 582* first run 583* = 2: Like 1, but use the seed values on the next line 584* 585* If line 6 was 2: 586* 587* line 7: INTEGER array, dimension (4) 588* Four integer values for the random number seed. 589* 590* If line 2 was 0: 591* 592* line 7-EOF: Precomputed examples are tested. 593* 594* remaining lines : Each example is stored on 3+2*N*N lines, where N is 595* its dimension. The first line contains the dimension (a 596* single integer). The next line contains an integer k such 597* that only the last k eigenvalues will be selected and appear 598* in the leading diagonal blocks of $A$ and $B$. The next N*N 599* lines contain the matrix A, one element per line. The next N*N 600* lines contain the matrix B. The last line contains the 601* reciprocal of the eigenvalue cluster condition number and the 602* reciprocal of the deflating subspace (associated with the 603* selected eigencluster) condition number. The end of data is 604* indicated by dimension N=0. Even if no data is to be tested, 605* there must be at least one line containing N=0. 606* 607*----------------------------------------------------------------------- 608* 609* ZXV input files: 610* line 1: 'ZXV' in columns 1 to 3. 611* 612* line 2: N, INTEGER 613* Value of N. 614* 615* line 3: NB, NBMIN, NX, NS, NBCOL, INTEGERs 616* These integer parameters determine how blocking is done 617* (see ILAENV for details) 618* NB : block size 619* NBMIN : minimum block size 620* NX : minimum dimension for blocking 621* NS : number of shifts in xHGEQR 622* NBCOL : minimum column dimension for blocking 623* 624* line 4: THRESH, REAL 625* The test threshold against which computed residuals are 626* compared. Should generally be in the range from 10. to 20. 627* Information will be printed about each test for which the 628* test ratio is greater than or equal to the threshold. 629* 630* line 5: TSTERR, LOGICAL 631* Flag indicating whether or not to test the error exits for 632* the LAPACK routines and driver routines. 633* 634* line 6: NEWSD, INTEGER 635* A code indicating how to set the random number seed. 636* = 0: Set the seed to a default value before each run 637* = 1: Initialize the seed to a default value only before the 638* first run 639* = 2: Like 1, but use the seed values on the next line 640* 641* If line 6 was 2: 642* 643* line 7: INTEGER array, dimension (4) 644* Four integer values for the random number seed. 645* 646* If line 2 was 0: 647* 648* line 7-EOF: Precomputed examples are tested. 649* 650* remaining lines : Each example is stored on 3+2*N*N lines, where N is 651* its dimension. The first line contains the dimension (a 652* single integer). The next N*N lines contain the matrix A, one 653* element per line. The next N*N lines contain the matrix B. 654* The next line contains the reciprocals of the eigenvalue 655* condition numbers. The last line contains the reciprocals of 656* the eigenvector condition numbers. The end of data is 657* indicated by dimension N=0. Even if no data is to be tested, 658* there must be at least one line containing N=0. 659* 660*----------------------------------------------------------------------- 661* 662* ZHB input file: 663* 664* line 2: NN, INTEGER 665* Number of values of N. 666* 667* line 3: NVAL, INTEGER array, dimension (NN) 668* The values for the matrix dimension N. 669* 670* line 4: NK, INTEGER 671* Number of values of K. 672* 673* line 5: KVAL, INTEGER array, dimension (NK) 674* The values for the matrix dimension K. 675* 676* line 6: THRESH 677* Threshold value for the test ratios. Information will be 678* printed about each test for which the test ratio is greater 679* than or equal to the threshold. 680* 681* line 7: NEWSD, INTEGER 682* A code indicating how to set the random number seed. 683* = 0: Set the seed to a default value before each run 684* = 1: Initialize the seed to a default value only before the 685* first run 686* = 2: Like 1, but use the seed values on the next line 687* 688* If line 7 was 2: 689* 690* line 8: INTEGER array, dimension (4) 691* Four integer values for the random number seed. 692* 693* lines 8-EOF: Lines specifying matrix types, as for NEP. 694* The 3-character path name is 'ZHB'. 695* 696*----------------------------------------------------------------------- 697* 698* ZBB input file: 699* 700* line 2: NN, INTEGER 701* Number of values of M and N. 702* 703* line 3: MVAL, INTEGER array, dimension (NN) 704* The values for the matrix row dimension M. 705* 706* line 4: NVAL, INTEGER array, dimension (NN) 707* The values for the matrix column dimension N. 708* 709* line 4: NK, INTEGER 710* Number of values of K. 711* 712* line 5: KVAL, INTEGER array, dimension (NK) 713* The values for the matrix bandwidth K. 714* 715* line 6: NPARMS, INTEGER 716* Number of values of the parameter NRHS 717* 718* line 7: NSVAL, INTEGER array, dimension (NPARMS) 719* The values for the number of right hand sides NRHS. 720* 721* line 8: THRESH 722* Threshold value for the test ratios. Information will be 723* printed about each test for which the test ratio is greater 724* than or equal to the threshold. 725* 726* line 9: NEWSD, INTEGER 727* A code indicating how to set the random number seed. 728* = 0: Set the seed to a default value before each run 729* = 1: Initialize the seed to a default value only before the 730* first run 731* = 2: Like 1, but use the seed values on the next line 732* 733* If line 9 was 2: 734* 735* line 10: INTEGER array, dimension (4) 736* Four integer values for the random number seed. 737* 738* lines 10-EOF: Lines specifying matrix types, as for SVD. 739* The 3-character path name is 'ZBB'. 740* 741*----------------------------------------------------------------------- 742* 743* ZEC input file: 744* 745* line 2: THRESH, REAL 746* Threshold value for the test ratios. Information will be 747* printed about each test for which the test ratio is greater 748* than or equal to the threshold. 749* 750* lines 3-EOF: 751* 752* Input for testing the eigencondition routines consists of a set of 753* specially constructed test cases and their solutions. The data 754* format is not intended to be modified by the user. 755* 756*----------------------------------------------------------------------- 757* 758* ZBL and ZBK input files: 759* 760* line 1: 'ZBL' in columns 1-3 to test CGEBAL, or 'ZBK' in 761* columns 1-3 to test CGEBAK. 762* 763* The remaining lines consist of specially constructed test cases. 764* 765*----------------------------------------------------------------------- 766* 767* ZGL and ZGK input files: 768* 769* line 1: 'ZGL' in columns 1-3 to test ZGGBAL, or 'ZGK' in 770* columns 1-3 to test ZGGBAK. 771* 772* The remaining lines consist of specially constructed test cases. 773* 774*----------------------------------------------------------------------- 775* 776* GLM data file: 777* 778* line 1: 'GLM' in columns 1 to 3. 779* 780* line 2: NN, INTEGER 781* Number of values of M, P, and N. 782* 783* line 3: MVAL, INTEGER array, dimension(NN) 784* Values of M (row dimension). 785* 786* line 4: PVAL, INTEGER array, dimension(NN) 787* Values of P (row dimension). 788* 789* line 5: NVAL, INTEGER array, dimension(NN) 790* Values of N (column dimension), note M <= N <= M+P. 791* 792* line 6: THRESH, REAL 793* Threshold value for the test ratios. Information will be 794* printed about each test for which the test ratio is greater 795* than or equal to the threshold. 796* 797* line 7: TSTERR, LOGICAL 798* Flag indicating whether or not to test the error exits for 799* the LAPACK routines and driver routines. 800* 801* line 8: NEWSD, INTEGER 802* A code indicating how to set the random number seed. 803* = 0: Set the seed to a default value before each run 804* = 1: Initialize the seed to a default value only before the 805* first run 806* = 2: Like 1, but use the seed values on the next line 807* 808* If line 8 was 2: 809* 810* line 9: INTEGER array, dimension (4) 811* Four integer values for the random number seed. 812* 813* lines 9-EOF: Lines specifying matrix types, as for NEP. 814* The 3-character path name is 'GLM' for the generalized 815* linear regression model routines. 816* 817*----------------------------------------------------------------------- 818* 819* GQR data file: 820* 821* line 1: 'GQR' in columns 1 to 3. 822* 823* line 2: NN, INTEGER 824* Number of values of M, P, and N. 825* 826* line 3: MVAL, INTEGER array, dimension(NN) 827* Values of M. 828* 829* line 4: PVAL, INTEGER array, dimension(NN) 830* Values of P. 831* 832* line 5: NVAL, INTEGER array, dimension(NN) 833* Values of N. 834* 835* line 6: THRESH, REAL 836* Threshold value for the test ratios. Information will be 837* printed about each test for which the test ratio is greater 838* than or equal to the threshold. 839* 840* line 7: TSTERR, LOGICAL 841* Flag indicating whether or not to test the error exits for 842* the LAPACK routines and driver routines. 843* 844* line 8: NEWSD, INTEGER 845* A code indicating how to set the random number seed. 846* = 0: Set the seed to a default value before each run 847* = 1: Initialize the seed to a default value only before the 848* first run 849* = 2: Like 1, but use the seed values on the next line 850* 851* If line 8 was 2: 852* 853* line 9: INTEGER array, dimension (4) 854* Four integer values for the random number seed. 855* 856* lines 9-EOF: Lines specifying matrix types, as for NEP. 857* The 3-character path name is 'GQR' for the generalized 858* QR and RQ routines. 859* 860*----------------------------------------------------------------------- 861* 862* GSV data file: 863* 864* line 1: 'GSV' in columns 1 to 3. 865* 866* line 2: NN, INTEGER 867* Number of values of M, P, and N. 868* 869* line 3: MVAL, INTEGER array, dimension(NN) 870* Values of M (row dimension). 871* 872* line 4: PVAL, INTEGER array, dimension(NN) 873* Values of P (row dimension). 874* 875* line 5: NVAL, INTEGER array, dimension(NN) 876* Values of N (column dimension). 877* 878* line 6: THRESH, REAL 879* Threshold value for the test ratios. Information will be 880* printed about each test for which the test ratio is greater 881* than or equal to the threshold. 882* 883* line 7: TSTERR, LOGICAL 884* Flag indicating whether or not to test the error exits for 885* the LAPACK routines and driver routines. 886* 887* line 8: NEWSD, INTEGER 888* A code indicating how to set the random number seed. 889* = 0: Set the seed to a default value before each run 890* = 1: Initialize the seed to a default value only before the 891* first run 892* = 2: Like 1, but use the seed values on the next line 893* 894* If line 8 was 2: 895* 896* line 9: INTEGER array, dimension (4) 897* Four integer values for the random number seed. 898* 899* lines 9-EOF: Lines specifying matrix types, as for NEP. 900* The 3-character path name is 'GSV' for the generalized 901* SVD routines. 902* 903*----------------------------------------------------------------------- 904* 905* LSE data file: 906* 907* line 1: 'LSE' in columns 1 to 3. 908* 909* line 2: NN, INTEGER 910* Number of values of M, P, and N. 911* 912* line 3: MVAL, INTEGER array, dimension(NN) 913* Values of M. 914* 915* line 4: PVAL, INTEGER array, dimension(NN) 916* Values of P. 917* 918* line 5: NVAL, INTEGER array, dimension(NN) 919* Values of N, note P <= N <= P+M. 920* 921* line 6: THRESH, REAL 922* Threshold value for the test ratios. Information will be 923* printed about each test for which the test ratio is greater 924* than or equal to the threshold. 925* 926* line 7: TSTERR, LOGICAL 927* Flag indicating whether or not to test the error exits for 928* the LAPACK routines and driver routines. 929* 930* line 8: NEWSD, INTEGER 931* A code indicating how to set the random number seed. 932* = 0: Set the seed to a default value before each run 933* = 1: Initialize the seed to a default value only before the 934* first run 935* = 2: Like 1, but use the seed values on the next line 936* 937* If line 8 was 2: 938* 939* line 9: INTEGER array, dimension (4) 940* Four integer values for the random number seed. 941* 942* lines 9-EOF: Lines specifying matrix types, as for NEP. 943* The 3-character path name is 'GSV' for the generalized 944* SVD routines. 945* 946*----------------------------------------------------------------------- 947* 948* NMAX is currently set to 132 and must be at least 12 for some of the 949* precomputed examples, and LWORK = NMAX*(5*NMAX+20) in the parameter 950* statements below. For SVD, we assume NRHS may be as big as N. The 951* parameter NEED is set to 14 to allow for 14 N-by-N matrices for ZGG. 952* 953* ===================================================================== 954* 955* .. Parameters .. 956 INTEGER NMAX 957 PARAMETER ( NMAX = 132 ) 958 INTEGER NCMAX 959 PARAMETER ( NCMAX = 20 ) 960 INTEGER NEED 961 PARAMETER ( NEED = 14 ) 962 INTEGER LWORK 963 PARAMETER ( LWORK = NMAX*( 5*NMAX+20 ) ) 964 INTEGER LIWORK 965!!!! 966 PARAMETER ( LIWORK = 2*NMAX*( NMAX+20 ) ) 967 INTEGER MAXIN 968 PARAMETER ( MAXIN = 20 ) 969 INTEGER MAXT 970 PARAMETER ( MAXT = 30 ) 971 INTEGER NIN, NOUT 972 PARAMETER ( NIN = 5, NOUT = 6 ) 973* .. 974* .. Local Scalars .. 975 LOGICAL ZBK, ZBL, ZES, ZEV, ZGK, ZGL, ZGS, ZGV, ZGX, 976 $ ZSX, ZVX, ZXV, FATAL, GLM, GQR, GSV, LSE, NEP, 977 $ SEP, SVD, TSTCHK, TSTDIF, TSTDRV, TSTERR, ZBB, 978 $ ZGG, ZHB 979 CHARACTER C1 980 CHARACTER*3 C3, PATH 981 CHARACTER*6 VNAME 982 CHARACTER*10 INTSTR 983 CHARACTER*80 LINE 984 INTEGER I, I1, IC, INFO, ITMP, K, LENP, MAXTYP, NEWSD, 985 $ NK, NN, NPARMS, NRHS, NTYPES 986 DOUBLE PRECISION EPS, S1, S2, THRESH, THRSHN 987* .. 988* .. Local Arrays .. 989 LOGICAL DOTYPE( MAXT ), LOGWRK( NMAX ) 990 INTEGER IOLDSD( 4 ), ISEED( 4 ), IWORK( LIWORK ), 991 $ KVAL( MAXIN ), MVAL( MAXIN ), MXBVAL( MAXIN ), 992 $ NBCOL( MAXIN ), NBMIN( MAXIN ), NBVAL( MAXIN ), 993 $ NSVAL( MAXIN ), NVAL( MAXIN ), NXVAL( MAXIN ), 994 $ PVAL( MAXIN ) 995 DOUBLE PRECISION ALPHA( NMAX ), BETA( NMAX ), DR( NMAX, 12 ), 996 $ RESULT( 500 ), RWORK( LWORK ), S( NMAX*NMAX ) 997 COMPLEX*16 A( NMAX*NMAX, NEED ), B( NMAX*NMAX, 5 ), 998 $ C( NCMAX*NCMAX, NCMAX*NCMAX ), DC( NMAX, 6 ), 999 $ TAUA( NMAX ), TAUB( NMAX ), WORK( LWORK ), 1000 $ X( 5*NMAX ) 1001* .. 1002* .. External Functions .. 1003 LOGICAL LSAMEN 1004 DOUBLE PRECISION DLAMCH, DSECND 1005 EXTERNAL LSAMEN, DLAMCH, DSECND 1006* .. 1007* .. External Subroutines .. 1008 EXTERNAL ALAREQ, XLAENV, ZCHKBB, ZCHKBD, ZCHKBK, ZCHKBL, 1009 $ ZCHKEC, ZCHKGG, ZCHKGK, ZCHKGL, ZCHKHB, ZCHKHS, 1010 $ ZCHKST, ZCKGLM, ZCKGQR, ZCKGSV, ZCKLSE, ZDRGES, 1011 $ ZDRGEV, ZDRGSX, ZDRGVX, ZDRVBD, ZDRVES, ZDRVEV, 1012 $ ZDRVGG, ZDRVSG, ZDRVST, ZDRVSX, ZDRVVX, ZERRBD, 1013 $ ZERRED, ZERRGG, ZERRHS, ZERRST 1014* .. 1015* .. Intrinsic Functions .. 1016 INTRINSIC LEN, MIN 1017* .. 1018* .. Scalars in Common .. 1019 LOGICAL LERR, OK 1020 CHARACTER*6 SRNAMT 1021 INTEGER INFOT, MAXB, NPROC, NSHIFT, NUNIT, SELDIM, 1022 $ SELOPT 1023* .. 1024* .. Arrays in Common .. 1025 LOGICAL SELVAL( 20 ) 1026 INTEGER IPARMS( 100 ) 1027 DOUBLE PRECISION SELWI( 20 ), SELWR( 20 ) 1028* .. 1029* .. Common blocks .. 1030 COMMON / CENVIR / NPROC, NSHIFT, MAXB 1031 COMMON / INFOC / INFOT, NUNIT, OK, LERR 1032 COMMON / SRNAMC / SRNAMT 1033 COMMON / SSLCT / SELOPT, SELDIM, SELVAL, SELWR, SELWI 1034 COMMON / ZLAENV / IPARMS 1035* .. 1036* .. Data statements .. 1037 DATA INTSTR / '0123456789' / 1038 DATA IOLDSD / 0, 0, 0, 1 / 1039* .. 1040* .. Executable Statements .. 1041* 1042 S1 = DSECND( ) 1043 FATAL = .FALSE. 1044 NUNIT = NOUT 1045* 1046* Return to here to read multiple sets of data 1047* 1048 10 CONTINUE 1049* 1050* Read the first line and set the 3-character test path 1051* 1052 READ( NIN, FMT = '(A80)', END = 380 )LINE 1053 PATH = LINE( 1: 3 ) 1054 NEP = LSAMEN( 3, PATH, 'NEP' ) .OR. LSAMEN( 3, PATH, 'ZHS' ) 1055 SEP = LSAMEN( 3, PATH, 'SEP' ) .OR. LSAMEN( 3, PATH, 'ZST' ) .OR. 1056 $ LSAMEN( 3, PATH, 'ZSG' ) 1057 SVD = LSAMEN( 3, PATH, 'SVD' ) .OR. LSAMEN( 3, PATH, 'ZBD' ) 1058 ZEV = LSAMEN( 3, PATH, 'ZEV' ) 1059 ZES = LSAMEN( 3, PATH, 'ZES' ) 1060 ZVX = LSAMEN( 3, PATH, 'ZVX' ) 1061 ZSX = LSAMEN( 3, PATH, 'ZSX' ) 1062 ZGG = LSAMEN( 3, PATH, 'ZGG' ) 1063 ZGS = LSAMEN( 3, PATH, 'ZGS' ) 1064 ZGX = LSAMEN( 3, PATH, 'ZGX' ) 1065 ZGV = LSAMEN( 3, PATH, 'ZGV' ) 1066 ZXV = LSAMEN( 3, PATH, 'ZXV' ) 1067 ZHB = LSAMEN( 3, PATH, 'ZHB' ) 1068 ZBB = LSAMEN( 3, PATH, 'ZBB' ) 1069 GLM = LSAMEN( 3, PATH, 'GLM' ) 1070 GQR = LSAMEN( 3, PATH, 'GQR' ) .OR. LSAMEN( 3, PATH, 'GRQ' ) 1071 GSV = LSAMEN( 3, PATH, 'GSV' ) 1072 LSE = LSAMEN( 3, PATH, 'LSE' ) 1073 ZBL = LSAMEN( 3, PATH, 'ZBL' ) 1074 ZBK = LSAMEN( 3, PATH, 'ZBK' ) 1075 ZGL = LSAMEN( 3, PATH, 'ZGL' ) 1076 ZGK = LSAMEN( 3, PATH, 'ZGK' ) 1077* 1078* Report values of parameters. 1079* 1080 IF( PATH.EQ.' ' ) THEN 1081 GO TO 10 1082 ELSE IF( NEP ) THEN 1083 WRITE( NOUT, FMT = 9987 ) 1084 ELSE IF( SEP ) THEN 1085 WRITE( NOUT, FMT = 9986 ) 1086 ELSE IF( SVD ) THEN 1087 WRITE( NOUT, FMT = 9985 ) 1088 ELSE IF( ZEV ) THEN 1089 WRITE( NOUT, FMT = 9979 ) 1090 ELSE IF( ZES ) THEN 1091 WRITE( NOUT, FMT = 9978 ) 1092 ELSE IF( ZVX ) THEN 1093 WRITE( NOUT, FMT = 9977 ) 1094 ELSE IF( ZSX ) THEN 1095 WRITE( NOUT, FMT = 9976 ) 1096 ELSE IF( ZGG ) THEN 1097 WRITE( NOUT, FMT = 9975 ) 1098 ELSE IF( ZGS ) THEN 1099 WRITE( NOUT, FMT = 9964 ) 1100 ELSE IF( ZGX ) THEN 1101 WRITE( NOUT, FMT = 9965 ) 1102 ELSE IF( ZGV ) THEN 1103 WRITE( NOUT, FMT = 9963 ) 1104 ELSE IF( ZXV ) THEN 1105 WRITE( NOUT, FMT = 9962 ) 1106 ELSE IF( ZHB ) THEN 1107 WRITE( NOUT, FMT = 9974 ) 1108 ELSE IF( ZBB ) THEN 1109 WRITE( NOUT, FMT = 9967 ) 1110 ELSE IF( GLM ) THEN 1111 WRITE( NOUT, FMT = 9971 ) 1112 ELSE IF( GQR ) THEN 1113 WRITE( NOUT, FMT = 9970 ) 1114 ELSE IF( GSV ) THEN 1115 WRITE( NOUT, FMT = 9969 ) 1116 ELSE IF( LSE ) THEN 1117 WRITE( NOUT, FMT = 9968 ) 1118 ELSE IF( ZBL ) THEN 1119* 1120* ZGEBAL: Balancing 1121* 1122 CALL ZCHKBL( NIN, NOUT ) 1123 GO TO 380 1124 ELSE IF( ZBK ) THEN 1125* 1126* ZGEBAK: Back transformation 1127* 1128 CALL ZCHKBK( NIN, NOUT ) 1129 GO TO 380 1130 ELSE IF( ZGL ) THEN 1131* 1132* ZGGBAL: Balancing 1133* 1134 CALL ZCHKGL( NIN, NOUT ) 1135 GO TO 380 1136 ELSE IF( ZGK ) THEN 1137* 1138* ZGGBAK: Back transformation 1139* 1140 CALL ZCHKGK( NIN, NOUT ) 1141 GO TO 380 1142 ELSE IF( LSAMEN( 3, PATH, 'ZEC' ) ) THEN 1143* 1144* ZEC: Eigencondition estimation 1145* 1146 READ( NIN, FMT = * )THRESH 1147 TSTERR = .TRUE. 1148 CALL ZCHKEC( THRESH, TSTERR, NIN, NOUT ) 1149 GO TO 380 1150 ELSE 1151 WRITE( NOUT, FMT = 9992 )PATH 1152 GO TO 380 1153 END IF 1154 WRITE( NOUT, FMT = 9972 ) 1155 WRITE( NOUT, FMT = 9984 ) 1156* 1157* Read the number of values of M, P, and N. 1158* 1159 READ( NIN, FMT = * )NN 1160 IF( NN.LT.0 ) THEN 1161 WRITE( NOUT, FMT = 9989 )' NN ', NN, 1 1162 NN = 0 1163 FATAL = .TRUE. 1164 ELSE IF( NN.GT.MAXIN ) THEN 1165 WRITE( NOUT, FMT = 9988 )' NN ', NN, MAXIN 1166 NN = 0 1167 FATAL = .TRUE. 1168 END IF 1169* 1170* Read the values of M 1171* 1172 IF( .NOT.( ZGX .OR. ZXV ) ) THEN 1173 READ( NIN, FMT = * )( MVAL( I ), I = 1, NN ) 1174 IF( SVD ) THEN 1175 VNAME = ' M ' 1176 ELSE 1177 VNAME = ' N ' 1178 END IF 1179 DO 20 I = 1, NN 1180 IF( MVAL( I ).LT.0 ) THEN 1181 WRITE( NOUT, FMT = 9989 )VNAME, MVAL( I ), 0 1182 FATAL = .TRUE. 1183 ELSE IF( MVAL( I ).GT.NMAX ) THEN 1184 WRITE( NOUT, FMT = 9988 )VNAME, MVAL( I ), NMAX 1185 FATAL = .TRUE. 1186 END IF 1187 20 CONTINUE 1188 WRITE( NOUT, FMT = 9983 )'M: ', ( MVAL( I ), I = 1, NN ) 1189 END IF 1190* 1191* Read the values of P 1192* 1193 IF( GLM .OR. GQR .OR. GSV .OR. LSE ) THEN 1194 READ( NIN, FMT = * )( PVAL( I ), I = 1, NN ) 1195 DO 30 I = 1, NN 1196 IF( PVAL( I ).LT.0 ) THEN 1197 WRITE( NOUT, FMT = 9989 )' P ', PVAL( I ), 0 1198 FATAL = .TRUE. 1199 ELSE IF( PVAL( I ).GT.NMAX ) THEN 1200 WRITE( NOUT, FMT = 9988 )' P ', PVAL( I ), NMAX 1201 FATAL = .TRUE. 1202 END IF 1203 30 CONTINUE 1204 WRITE( NOUT, FMT = 9983 )'P: ', ( PVAL( I ), I = 1, NN ) 1205 END IF 1206* 1207* Read the values of N 1208* 1209 IF( SVD .OR. ZBB .OR. GLM .OR. GQR .OR. GSV .OR. LSE ) THEN 1210 READ( NIN, FMT = * )( NVAL( I ), I = 1, NN ) 1211 DO 40 I = 1, NN 1212 IF( NVAL( I ).LT.0 ) THEN 1213 WRITE( NOUT, FMT = 9989 )' N ', NVAL( I ), 0 1214 FATAL = .TRUE. 1215 ELSE IF( NVAL( I ).GT.NMAX ) THEN 1216 WRITE( NOUT, FMT = 9988 )' N ', NVAL( I ), NMAX 1217 FATAL = .TRUE. 1218 END IF 1219 40 CONTINUE 1220 ELSE 1221 DO 50 I = 1, NN 1222 NVAL( I ) = MVAL( I ) 1223 50 CONTINUE 1224 END IF 1225 IF( .NOT.( ZGX .OR. ZXV ) ) THEN 1226 WRITE( NOUT, FMT = 9983 )'N: ', ( NVAL( I ), I = 1, NN ) 1227 ELSE 1228 WRITE( NOUT, FMT = 9983 )'N: ', NN 1229 END IF 1230* 1231* Read the number of values of K, followed by the values of K 1232* 1233 IF( ZHB .OR. ZBB ) THEN 1234 READ( NIN, FMT = * )NK 1235 READ( NIN, FMT = * )( KVAL( I ), I = 1, NK ) 1236 DO 60 I = 1, NK 1237 IF( KVAL( I ).LT.0 ) THEN 1238 WRITE( NOUT, FMT = 9989 )' K ', KVAL( I ), 0 1239 FATAL = .TRUE. 1240 ELSE IF( KVAL( I ).GT.NMAX ) THEN 1241 WRITE( NOUT, FMT = 9988 )' K ', KVAL( I ), NMAX 1242 FATAL = .TRUE. 1243 END IF 1244 60 CONTINUE 1245 WRITE( NOUT, FMT = 9983 )'K: ', ( KVAL( I ), I = 1, NK ) 1246 END IF 1247* 1248 IF( ZEV .OR. ZES .OR. ZVX .OR. ZSX .OR. ZGS .OR. ZGX .OR. ZGV .OR. 1249 $ ZXV ) THEN 1250* 1251* For the nonsymmetric driver routines, only one set of 1252* parameters is allowed. 1253* 1254 READ( NIN, FMT = * )NBVAL( 1 ), NBMIN( 1 ), NXVAL( 1 ), 1255 $ NSVAL( 1 ), MXBVAL( 1 ) 1256 IF( NBVAL( 1 ).LT.1 ) THEN 1257 WRITE( NOUT, FMT = 9989 )' NB ', NBVAL( 1 ), 1 1258 FATAL = .TRUE. 1259 ELSE IF( NBMIN( 1 ).LT.1 ) THEN 1260 WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( 1 ), 1 1261 FATAL = .TRUE. 1262 ELSE IF( NXVAL( 1 ).LT.1 ) THEN 1263 WRITE( NOUT, FMT = 9989 )' NX ', NXVAL( 1 ), 1 1264 FATAL = .TRUE. 1265 ELSE IF( NSVAL( 1 ).LT.2 ) THEN 1266 WRITE( NOUT, FMT = 9989 )' NS ', NSVAL( 1 ), 2 1267 FATAL = .TRUE. 1268 ELSE IF( MXBVAL( 1 ).LT.1 ) THEN 1269 WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( 1 ), 1 1270 FATAL = .TRUE. 1271 END IF 1272 CALL XLAENV( 1, NBVAL( 1 ) ) 1273 CALL XLAENV( 2, NBMIN( 1 ) ) 1274 CALL XLAENV( 3, NXVAL( 1 ) ) 1275 CALL XLAENV( 4, NSVAL( 1 ) ) 1276 CALL XLAENV( 8, MXBVAL( 1 ) ) 1277 WRITE( NOUT, FMT = 9983 )'NB: ', NBVAL( 1 ) 1278 WRITE( NOUT, FMT = 9983 )'NBMIN:', NBMIN( 1 ) 1279 WRITE( NOUT, FMT = 9983 )'NX: ', NXVAL( 1 ) 1280 WRITE( NOUT, FMT = 9983 )'NS: ', NSVAL( 1 ) 1281 WRITE( NOUT, FMT = 9983 )'MAXB: ', MXBVAL( 1 ) 1282 ELSE IF( .NOT.ZHB .AND. .NOT.GLM .AND. .NOT.GQR .AND. .NOT. 1283 $ GSV .AND. .NOT.LSE ) THEN 1284* 1285* For the other paths, the number of parameters can be varied 1286* from the input file. Read the number of parameter values. 1287* 1288 READ( NIN, FMT = * )NPARMS 1289 IF( NPARMS.LT.1 ) THEN 1290 WRITE( NOUT, FMT = 9989 )'NPARMS', NPARMS, 1 1291 NPARMS = 0 1292 FATAL = .TRUE. 1293 ELSE IF( NPARMS.GT.MAXIN ) THEN 1294 WRITE( NOUT, FMT = 9988 )'NPARMS', NPARMS, MAXIN 1295 NPARMS = 0 1296 FATAL = .TRUE. 1297 END IF 1298* 1299* Read the values of NB 1300* 1301 IF( .NOT.ZBB ) THEN 1302 READ( NIN, FMT = * )( NBVAL( I ), I = 1, NPARMS ) 1303 DO 70 I = 1, NPARMS 1304 IF( NBVAL( I ).LT.0 ) THEN 1305 WRITE( NOUT, FMT = 9989 )' NB ', NBVAL( I ), 0 1306 FATAL = .TRUE. 1307 ELSE IF( NBVAL( I ).GT.NMAX ) THEN 1308 WRITE( NOUT, FMT = 9988 )' NB ', NBVAL( I ), NMAX 1309 FATAL = .TRUE. 1310 END IF 1311 70 CONTINUE 1312 WRITE( NOUT, FMT = 9983 )'NB: ', 1313 $ ( NBVAL( I ), I = 1, NPARMS ) 1314 END IF 1315* 1316* Read the values of NBMIN 1317* 1318 IF( NEP .OR. SEP .OR. SVD .OR. ZGG ) THEN 1319 READ( NIN, FMT = * )( NBMIN( I ), I = 1, NPARMS ) 1320 DO 80 I = 1, NPARMS 1321 IF( NBMIN( I ).LT.0 ) THEN 1322 WRITE( NOUT, FMT = 9989 )'NBMIN ', NBMIN( I ), 0 1323 FATAL = .TRUE. 1324 ELSE IF( NBMIN( I ).GT.NMAX ) THEN 1325 WRITE( NOUT, FMT = 9988 )'NBMIN ', NBMIN( I ), NMAX 1326 FATAL = .TRUE. 1327 END IF 1328 80 CONTINUE 1329 WRITE( NOUT, FMT = 9983 )'NBMIN:', 1330 $ ( NBMIN( I ), I = 1, NPARMS ) 1331 ELSE 1332 DO 90 I = 1, NPARMS 1333 NBMIN( I ) = 1 1334 90 CONTINUE 1335 END IF 1336* 1337* Read the values of NX 1338* 1339 IF( NEP .OR. SEP .OR. SVD ) THEN 1340 READ( NIN, FMT = * )( NXVAL( I ), I = 1, NPARMS ) 1341 DO 100 I = 1, NPARMS 1342 IF( NXVAL( I ).LT.0 ) THEN 1343 WRITE( NOUT, FMT = 9989 )' NX ', NXVAL( I ), 0 1344 FATAL = .TRUE. 1345 ELSE IF( NXVAL( I ).GT.NMAX ) THEN 1346 WRITE( NOUT, FMT = 9988 )' NX ', NXVAL( I ), NMAX 1347 FATAL = .TRUE. 1348 END IF 1349 100 CONTINUE 1350 WRITE( NOUT, FMT = 9983 )'NX: ', 1351 $ ( NXVAL( I ), I = 1, NPARMS ) 1352 ELSE 1353 DO 110 I = 1, NPARMS 1354 NXVAL( I ) = 1 1355 110 CONTINUE 1356 END IF 1357* 1358* Read the values of NSHIFT (if NEP or ZGG) or NRHS (if SVD 1359* or ZBB). 1360* 1361 IF( NEP .OR. SVD .OR. ZBB .OR. ZGG ) THEN 1362 READ( NIN, FMT = * )( NSVAL( I ), I = 1, NPARMS ) 1363 DO 120 I = 1, NPARMS 1364 IF( NSVAL( I ).LT.0 ) THEN 1365 WRITE( NOUT, FMT = 9989 )' NS ', NSVAL( I ), 0 1366 FATAL = .TRUE. 1367 ELSE IF( NSVAL( I ).GT.NMAX ) THEN 1368 WRITE( NOUT, FMT = 9988 )' NS ', NSVAL( I ), NMAX 1369 FATAL = .TRUE. 1370 END IF 1371 120 CONTINUE 1372 WRITE( NOUT, FMT = 9983 )'NS: ', 1373 $ ( NSVAL( I ), I = 1, NPARMS ) 1374 ELSE 1375 DO 130 I = 1, NPARMS 1376 NSVAL( I ) = 1 1377 130 CONTINUE 1378 END IF 1379* 1380* Read the values for MAXB. 1381* 1382 IF( NEP .OR. ZGG ) THEN 1383 READ( NIN, FMT = * )( MXBVAL( I ), I = 1, NPARMS ) 1384 DO 140 I = 1, NPARMS 1385 IF( MXBVAL( I ).LT.0 ) THEN 1386 WRITE( NOUT, FMT = 9989 )' MAXB ', MXBVAL( I ), 0 1387 FATAL = .TRUE. 1388 ELSE IF( MXBVAL( I ).GT.NMAX ) THEN 1389 WRITE( NOUT, FMT = 9988 )' MAXB ', MXBVAL( I ), NMAX 1390 FATAL = .TRUE. 1391 END IF 1392 140 CONTINUE 1393 WRITE( NOUT, FMT = 9983 )'MAXB: ', 1394 $ ( MXBVAL( I ), I = 1, NPARMS ) 1395 ELSE 1396 DO 150 I = 1, NPARMS 1397 MXBVAL( I ) = 1 1398 150 CONTINUE 1399 END IF 1400* 1401* Read the values for NBCOL. 1402* 1403 IF( ZGG ) THEN 1404 READ( NIN, FMT = * )( NBCOL( I ), I = 1, NPARMS ) 1405 DO 160 I = 1, NPARMS 1406 IF( NBCOL( I ).LT.0 ) THEN 1407 WRITE( NOUT, FMT = 9989 )'NBCOL ', NBCOL( I ), 0 1408 FATAL = .TRUE. 1409 ELSE IF( NBCOL( I ).GT.NMAX ) THEN 1410 WRITE( NOUT, FMT = 9988 )'NBCOL ', NBCOL( I ), NMAX 1411 FATAL = .TRUE. 1412 END IF 1413 160 CONTINUE 1414 WRITE( NOUT, FMT = 9983 )'NBCOL:', 1415 $ ( NBCOL( I ), I = 1, NPARMS ) 1416 ELSE 1417 DO 170 I = 1, NPARMS 1418 NBCOL( I ) = 1 1419 170 CONTINUE 1420 END IF 1421 END IF 1422* 1423* Calculate and print the machine dependent constants. 1424* 1425 WRITE( NOUT, FMT = * ) 1426 EPS = DLAMCH( 'Underflow threshold' ) 1427 WRITE( NOUT, FMT = 9981 )'underflow', EPS 1428 EPS = DLAMCH( 'Overflow threshold' ) 1429 WRITE( NOUT, FMT = 9981 )'overflow ', EPS 1430 EPS = DLAMCH( 'Epsilon' ) 1431 WRITE( NOUT, FMT = 9981 )'precision', EPS 1432* 1433* Read the threshold value for the test ratios. 1434* 1435 READ( NIN, FMT = * )THRESH 1436 WRITE( NOUT, FMT = 9982 )THRESH 1437 IF( SEP .OR. SVD .OR. ZGG ) THEN 1438* 1439* Read the flag that indicates whether to test LAPACK routines. 1440* 1441 READ( NIN, FMT = * )TSTCHK 1442* 1443* Read the flag that indicates whether to test driver routines. 1444* 1445 READ( NIN, FMT = * )TSTDRV 1446 END IF 1447* 1448* Read the flag that indicates whether to test the error exits. 1449* 1450 READ( NIN, FMT = * )TSTERR 1451* 1452* Read the code describing how to set the random number seed. 1453* 1454 READ( NIN, FMT = * )NEWSD 1455* 1456* If NEWSD = 2, read another line with 4 integers for the seed. 1457* 1458 IF( NEWSD.EQ.2 ) 1459 $ READ( NIN, FMT = * )( IOLDSD( I ), I = 1, 4 ) 1460* 1461 DO 180 I = 1, 4 1462 ISEED( I ) = IOLDSD( I ) 1463 180 CONTINUE 1464* 1465 IF( FATAL ) THEN 1466 WRITE( NOUT, FMT = 9999 ) 1467 STOP 1468 END IF 1469* 1470* Read the input lines indicating the test path and its parameters. 1471* The first three characters indicate the test path, and the number 1472* of test matrix types must be the first nonblank item in columns 1473* 4-80. 1474* 1475 190 CONTINUE 1476* 1477 IF( .NOT.( ZGX .OR. ZXV ) ) THEN 1478* 1479 200 CONTINUE 1480 READ( NIN, FMT = '(A80)', END = 380 )LINE 1481 C3 = LINE( 1: 3 ) 1482 LENP = LEN( LINE ) 1483 I = 3 1484 ITMP = 0 1485 I1 = 0 1486 210 CONTINUE 1487 I = I + 1 1488 IF( I.GT.LENP ) THEN 1489 IF( I1.GT.0 ) THEN 1490 GO TO 240 1491 ELSE 1492 NTYPES = MAXT 1493 GO TO 240 1494 END IF 1495 END IF 1496 IF( LINE( I: I ).NE.' ' .AND. LINE( I: I ).NE.',' ) THEN 1497 I1 = I 1498 C1 = LINE( I1: I1 ) 1499* 1500* Check that a valid integer was read 1501* 1502 DO 220 K = 1, 10 1503 IF( C1.EQ.INTSTR( K: K ) ) THEN 1504 IC = K - 1 1505 GO TO 230 1506 END IF 1507 220 CONTINUE 1508 WRITE( NOUT, FMT = 9991 )I, LINE 1509 GO TO 200 1510 230 CONTINUE 1511 ITMP = 10*ITMP + IC 1512 GO TO 210 1513 ELSE IF( I1.GT.0 ) THEN 1514 GO TO 240 1515 ELSE 1516 GO TO 210 1517 END IF 1518 240 CONTINUE 1519 NTYPES = ITMP 1520* 1521* Skip the tests if NTYPES is <= 0. 1522* 1523 IF( .NOT.( ZEV .OR. ZES .OR. ZVX .OR. ZSX .OR. ZGV .OR. 1524 $ ZGS ) .AND. NTYPES.LE.0 ) THEN 1525 WRITE( NOUT, FMT = 9990 )C3 1526 GO TO 200 1527 END IF 1528* 1529 ELSE 1530 IF( ZGX ) 1531 $ C3 = 'ZGX' 1532 IF( ZXV ) 1533 $ C3 = 'ZXV' 1534 END IF 1535* 1536* Reset the random number seed. 1537* 1538 IF( NEWSD.EQ.0 ) THEN 1539 DO 250 K = 1, 4 1540 ISEED( K ) = IOLDSD( K ) 1541 250 CONTINUE 1542 END IF 1543* 1544 IF( LSAMEN( 3, C3, 'ZHS' ) .OR. LSAMEN( 3, C3, 'NEP' ) ) THEN 1545* 1546* ------------------------------------- 1547* NEP: Nonsymmetric Eigenvalue Problem 1548* ------------------------------------- 1549* Vary the parameters 1550* NB = block size 1551* NBMIN = minimum block size 1552* NX = crossover point 1553* NS = number of shifts 1554* MAXB = minimum submatrix size 1555* 1556 MAXTYP = 21 1557 NTYPES = MIN( MAXTYP, NTYPES ) 1558 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1559 IF( TSTERR ) 1560 $ CALL ZERRHS( 'ZHSEQR', NOUT ) 1561 DO 270 I = 1, NPARMS 1562 CALL XLAENV( 1, NBVAL( I ) ) 1563 CALL XLAENV( 2, NBMIN( I ) ) 1564 CALL XLAENV( 3, NXVAL( I ) ) 1565 CALL XLAENV( 4, NSVAL( I ) ) 1566 CALL XLAENV( 8, MXBVAL( I ) ) 1567* 1568 IF( NEWSD.EQ.0 ) THEN 1569 DO 260 K = 1, 4 1570 ISEED( K ) = IOLDSD( K ) 1571 260 CONTINUE 1572 END IF 1573 WRITE( NOUT, FMT = 9998 )C3, NBVAL( I ), NBMIN( I ), 1574 $ NXVAL( I ), NSVAL( I ), MXBVAL( I ) 1575 CALL ZCHKHS( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT, 1576 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 1577 $ A( 1, 4 ), A( 1, 5 ), NMAX, A( 1, 6 ), 1578 $ A( 1, 7 ), DC( 1, 1 ), DC( 1, 2 ), A( 1, 8 ), 1579 $ A( 1, 9 ), A( 1, 10 ), A( 1, 11 ), A( 1, 12 ), 1580 $ DC( 1, 3 ), WORK, LWORK, RWORK, IWORK, LOGWRK, 1581 $ RESULT, INFO ) 1582 IF( INFO.NE.0 ) 1583 $ WRITE( NOUT, FMT = 9980 )'ZCHKHS', INFO 1584 270 CONTINUE 1585* 1586 ELSE IF( LSAMEN( 3, C3, 'ZST' ) .OR. LSAMEN( 3, C3, 'SEP' ) ) THEN 1587* 1588* ---------------------------------- 1589* SEP: Symmetric Eigenvalue Problem 1590* ---------------------------------- 1591* Vary the parameters 1592* NB = block size 1593* NBMIN = minimum block size 1594* NX = crossover point 1595* 1596 MAXTYP = 21 1597 NTYPES = MIN( MAXTYP, NTYPES ) 1598 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1599 CALL XLAENV( 9, 25 ) 1600 IF( TSTERR ) 1601 $ CALL ZERRST( 'ZST', NOUT ) 1602 DO 290 I = 1, NPARMS 1603 CALL XLAENV( 1, NBVAL( I ) ) 1604 CALL XLAENV( 2, NBMIN( I ) ) 1605 CALL XLAENV( 3, NXVAL( I ) ) 1606* 1607 IF( NEWSD.EQ.0 ) THEN 1608 DO 280 K = 1, 4 1609 ISEED( K ) = IOLDSD( K ) 1610 280 CONTINUE 1611 END IF 1612 WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ), 1613 $ NXVAL( I ) 1614 IF( TSTCHK ) THEN 1615 CALL ZCHKST( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 1616 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), 1617 $ DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ), 1618 $ DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), 1619 $ DR( 1, 7 ), DR( 1, 8 ), DR( 1, 9 ), 1620 $ DR( 1, 10 ), DR( 1, 11 ), A( 1, 3 ), NMAX, 1621 $ A( 1, 4 ), A( 1, 5 ), DC( 1, 1 ), A( 1, 6 ), 1622 $ WORK, LWORK, RWORK, LWORK, IWORK, LIWORK, 1623 $ RESULT, INFO ) 1624 IF( INFO.NE.0 ) 1625 $ WRITE( NOUT, FMT = 9980 )'ZCHKST', INFO 1626 END IF 1627 IF( TSTDRV ) THEN 1628 INFO = 0 1629 CALL ZDRVST( NN, NVAL, 18, DOTYPE, ISEED, THRESH, NOUT, 1630 $ A( 1, 1 ), NMAX, DR( 1, 3 ), DR( 1, 4 ), 1631 $ DR( 1, 5 ), DR( 1, 8 ), DR( 1, 9 ), 1632 $ DR( 1, 10 ), A( 1, 2 ), NMAX, A( 1, 3 ), 1633 $ DC( 1, 1 ), A( 1, 4 ), WORK, LWORK, RWORK, 1634 $ LWORK, IWORK, LIWORK, RESULT, INFO ) 1635 IF( INFO.NE.0 ) 1636 $ WRITE( NOUT, FMT = 9980 )'ZDRVST', INFO 1637 END IF 1638 290 CONTINUE 1639* 1640 ELSE IF( LSAMEN( 3, C3, 'ZSG' ) ) THEN 1641* 1642* ---------------------------------------------- 1643* ZSG: Hermitian Generalized Eigenvalue Problem 1644* ---------------------------------------------- 1645* Vary the parameters 1646* NB = block size 1647* NBMIN = minimum block size 1648* NX = crossover point 1649* 1650 MAXTYP = 21 1651 NTYPES = MIN( MAXTYP, NTYPES ) 1652 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1653 CALL XLAENV( 9, 25 ) 1654 DO 310 I = 1, NPARMS 1655 CALL XLAENV( 1, NBVAL( I ) ) 1656 CALL XLAENV( 2, NBMIN( I ) ) 1657 CALL XLAENV( 3, NXVAL( I ) ) 1658* 1659 IF( NEWSD.EQ.0 ) THEN 1660 DO 300 K = 1, 4 1661 ISEED( K ) = IOLDSD( K ) 1662 300 CONTINUE 1663 END IF 1664 WRITE( NOUT, FMT = 9997 )C3, NBVAL( I ), NBMIN( I ), 1665 $ NXVAL( I ) 1666 IF( TSTCHK ) THEN 1667 CALL ZDRVSG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 1668 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX, 1669 $ DR( 1, 3 ), A( 1, 3 ), NMAX, A( 1, 4 ), 1670 $ A( 1, 5 ), A( 1, 6 ), A( 1, 7 ), WORK, 1671 $ LWORK, RWORK, LWORK, IWORK, LIWORK, RESULT, 1672 $ INFO ) 1673 IF( INFO.NE.0 ) 1674 $ WRITE( NOUT, FMT = 9980 )'ZDRVSG', INFO 1675 END IF 1676 310 CONTINUE 1677* 1678 ELSE IF( LSAMEN( 3, C3, 'ZBD' ) .OR. LSAMEN( 3, C3, 'SVD' ) ) THEN 1679* 1680* ---------------------------------- 1681* SVD: Singular Value Decomposition 1682* ---------------------------------- 1683* Vary the parameters 1684* NB = block size 1685* NBMIN = minimum block size 1686* NX = crossover point 1687* NRHS = number of right hand sides 1688* 1689 MAXTYP = 16 1690 NTYPES = MIN( MAXTYP, NTYPES ) 1691 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1692 CALL XLAENV( 9, 25 ) 1693* 1694* Test the error exits 1695* 1696 IF( TSTERR .AND. TSTCHK ) 1697 $ CALL ZERRBD( 'ZBD', NOUT ) 1698 IF( TSTERR .AND. TSTDRV ) 1699 $ CALL ZERRED( 'ZBD', NOUT ) 1700* 1701 DO 330 I = 1, NPARMS 1702 NRHS = NSVAL( I ) 1703 CALL XLAENV( 1, NBVAL( I ) ) 1704 CALL XLAENV( 2, NBMIN( I ) ) 1705 CALL XLAENV( 3, NXVAL( I ) ) 1706 IF( NEWSD.EQ.0 ) THEN 1707 DO 320 K = 1, 4 1708 ISEED( K ) = IOLDSD( K ) 1709 320 CONTINUE 1710 END IF 1711 WRITE( NOUT, FMT = 9995 )C3, NBVAL( I ), NBMIN( I ), 1712 $ NXVAL( I ), NRHS 1713 IF( TSTCHK ) THEN 1714 CALL ZCHKBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, NRHS, ISEED, 1715 $ THRESH, A( 1, 1 ), NMAX, DR( 1, 1 ), 1716 $ DR( 1, 2 ), DR( 1, 3 ), DR( 1, 4 ), 1717 $ A( 1, 2 ), NMAX, A( 1, 3 ), A( 1, 4 ), 1718 $ A( 1, 5 ), NMAX, A( 1, 6 ), NMAX, A( 1, 7 ), 1719 $ A( 1, 8 ), WORK, LWORK, RWORK, NOUT, INFO ) 1720 IF( INFO.NE.0 ) 1721 $ WRITE( NOUT, FMT = 9980 )'ZCHKBD', INFO 1722 END IF 1723 IF( TSTDRV ) 1724 $ CALL ZDRVBD( NN, MVAL, NVAL, MAXTYP, DOTYPE, ISEED, 1725 $ THRESH, A( 1, 1 ), NMAX, A( 1, 2 ), NMAX, 1726 $ A( 1, 3 ), NMAX, A( 1, 4 ), A( 1, 5 ), 1727 $ A( 1, 6 ), DR( 1, 1 ), DR( 1, 2 ), 1728 $ DR( 1, 3 ), WORK, LWORK, RWORK, IWORK, NOUT, 1729 $ INFO ) 1730 330 CONTINUE 1731* 1732 ELSE IF( LSAMEN( 3, C3, 'ZEV' ) ) THEN 1733* 1734* -------------------------------------------- 1735* ZEV: Nonsymmetric Eigenvalue Problem Driver 1736* ZGEEV (eigenvalues and eigenvectors) 1737* -------------------------------------------- 1738* 1739 MAXTYP = 21 1740 NTYPES = MIN( MAXTYP, NTYPES ) 1741 IF( NTYPES.LE.0 ) THEN 1742 WRITE( NOUT, FMT = 9990 )C3 1743 ELSE 1744 IF( TSTERR ) 1745 $ CALL ZERRED( C3, NOUT ) 1746 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1747 CALL ZDRVEV( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT, 1748 $ A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ), 1749 $ DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX, 1750 $ A( 1, 5 ), NMAX, RESULT, WORK, LWORK, RWORK, 1751 $ IWORK, INFO ) 1752 IF( INFO.NE.0 ) 1753 $ WRITE( NOUT, FMT = 9980 )'ZGEEV', INFO 1754 END IF 1755 WRITE( NOUT, FMT = 9973 ) 1756 GO TO 10 1757* 1758 ELSE IF( LSAMEN( 3, C3, 'ZES' ) ) THEN 1759* 1760* -------------------------------------------- 1761* ZES: Nonsymmetric Eigenvalue Problem Driver 1762* ZGEES (Schur form) 1763* -------------------------------------------- 1764* 1765 MAXTYP = 21 1766 NTYPES = MIN( MAXTYP, NTYPES ) 1767 IF( NTYPES.LE.0 ) THEN 1768 WRITE( NOUT, FMT = 9990 )C3 1769 ELSE 1770 IF( TSTERR ) 1771 $ CALL ZERRED( C3, NOUT ) 1772 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1773 CALL ZDRVES( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NOUT, 1774 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 1775 $ DC( 1, 1 ), DC( 1, 2 ), A( 1, 4 ), NMAX, 1776 $ RESULT, WORK, LWORK, RWORK, IWORK, LOGWRK, 1777 $ INFO ) 1778 IF( INFO.NE.0 ) 1779 $ WRITE( NOUT, FMT = 9980 )'ZGEES', INFO 1780 END IF 1781 WRITE( NOUT, FMT = 9973 ) 1782 GO TO 10 1783* 1784 ELSE IF( LSAMEN( 3, C3, 'ZVX' ) ) THEN 1785* 1786* -------------------------------------------------------------- 1787* ZVX: Nonsymmetric Eigenvalue Problem Expert Driver 1788* ZGEEVX (eigenvalues, eigenvectors and condition numbers) 1789* -------------------------------------------------------------- 1790* 1791 MAXTYP = 21 1792 NTYPES = MIN( MAXTYP, NTYPES ) 1793 IF( NTYPES.LT.0 ) THEN 1794 WRITE( NOUT, FMT = 9990 )C3 1795 ELSE 1796 IF( TSTERR ) 1797 $ CALL ZERRED( C3, NOUT ) 1798 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1799 CALL ZDRVVX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN, 1800 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), DC( 1, 1 ), 1801 $ DC( 1, 2 ), A( 1, 3 ), NMAX, A( 1, 4 ), NMAX, 1802 $ A( 1, 5 ), NMAX, DR( 1, 1 ), DR( 1, 2 ), 1803 $ DR( 1, 3 ), DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), 1804 $ DR( 1, 7 ), DR( 1, 8 ), RESULT, WORK, LWORK, 1805 $ RWORK, INFO ) 1806 IF( INFO.NE.0 ) 1807 $ WRITE( NOUT, FMT = 9980 )'ZGEEVX', INFO 1808 END IF 1809 WRITE( NOUT, FMT = 9973 ) 1810 GO TO 10 1811* 1812 ELSE IF( LSAMEN( 3, C3, 'ZSX' ) ) THEN 1813* 1814* --------------------------------------------------- 1815* ZSX: Nonsymmetric Eigenvalue Problem Expert Driver 1816* ZGEESX (Schur form and condition numbers) 1817* --------------------------------------------------- 1818* 1819 MAXTYP = 21 1820 NTYPES = MIN( MAXTYP, NTYPES ) 1821 IF( NTYPES.LT.0 ) THEN 1822 WRITE( NOUT, FMT = 9990 )C3 1823 ELSE 1824 IF( TSTERR ) 1825 $ CALL ZERRED( C3, NOUT ) 1826 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1827 CALL ZDRVSX( NN, NVAL, NTYPES, DOTYPE, ISEED, THRESH, NIN, 1828 $ NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 1829 $ DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), A( 1, 4 ), 1830 $ NMAX, A( 1, 5 ), RESULT, WORK, LWORK, RWORK, 1831 $ LOGWRK, INFO ) 1832 IF( INFO.NE.0 ) 1833 $ WRITE( NOUT, FMT = 9980 )'ZGEESX', INFO 1834 END IF 1835 WRITE( NOUT, FMT = 9973 ) 1836 GO TO 10 1837* 1838 ELSE IF( LSAMEN( 3, C3, 'ZGG' ) ) THEN 1839* 1840* ------------------------------------------------- 1841* ZGG: Generalized Nonsymmetric Eigenvalue Problem 1842* ------------------------------------------------- 1843* Vary the parameters 1844* NB = block size 1845* NBMIN = minimum block size 1846* NS = number of shifts 1847* MAXB = minimum submatrix size 1848* NBCOL = minimum column dimension for blocks 1849* 1850 MAXTYP = 26 1851 NTYPES = MIN( MAXTYP, NTYPES ) 1852 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1853 IF( TSTCHK .AND. TSTERR ) 1854 $ CALL ZERRGG( C3, NOUT ) 1855 DO 350 I = 1, NPARMS 1856 CALL XLAENV( 1, NBVAL( I ) ) 1857 CALL XLAENV( 2, NBMIN( I ) ) 1858 CALL XLAENV( 4, NSVAL( I ) ) 1859 CALL XLAENV( 8, MXBVAL( I ) ) 1860 CALL XLAENV( 5, NBCOL( I ) ) 1861* 1862 IF( NEWSD.EQ.0 ) THEN 1863 DO 340 K = 1, 4 1864 ISEED( K ) = IOLDSD( K ) 1865 340 CONTINUE 1866 END IF 1867 WRITE( NOUT, FMT = 9996 )C3, NBVAL( I ), NBMIN( I ), 1868 $ NSVAL( I ), MXBVAL( I ), NBCOL( I ) 1869 TSTDIF = .FALSE. 1870 THRSHN = 10.D0 1871 IF( TSTCHK ) THEN 1872 CALL ZCHKGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 1873 $ TSTDIF, THRSHN, NOUT, A( 1, 1 ), NMAX, 1874 $ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), 1875 $ A( 1, 6 ), A( 1, 7 ), A( 1, 8 ), A( 1, 9 ), 1876 $ NMAX, A( 1, 10 ), A( 1, 11 ), A( 1, 12 ), 1877 $ DC( 1, 1 ), DC( 1, 2 ), DC( 1, 3 ), 1878 $ DC( 1, 4 ), A( 1, 13 ), A( 1, 14 ), WORK, 1879 $ LWORK, RWORK, LOGWRK, RESULT, INFO ) 1880 IF( INFO.NE.0 ) 1881 $ WRITE( NOUT, FMT = 9980 )'ZCHKGG', INFO 1882 END IF 1883 IF( TSTDRV ) THEN 1884 CALL ZDRVGG( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, 1885 $ THRSHN, NOUT, A( 1, 1 ), NMAX, A( 1, 2 ), 1886 $ A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), A( 1, 6 ), 1887 $ A( 1, 7 ), NMAX, A( 1, 8 ), DC( 1, 1 ), 1888 $ DC( 1, 2 ), DC( 1, 3 ), DC( 1, 4 ), 1889 $ A( 1, 8 ), A( 1, 9 ), WORK, LWORK, RWORK, 1890 $ RESULT, INFO ) 1891 IF( INFO.NE.0 ) 1892 $ WRITE( NOUT, FMT = 9980 )'ZDRVGG', INFO 1893 END IF 1894 350 CONTINUE 1895* 1896 ELSE IF( LSAMEN( 3, C3, 'ZGS' ) ) THEN 1897* 1898* ------------------------------------------------- 1899* ZGS: Generalized Nonsymmetric Eigenvalue Problem 1900* ZGGES (Schur form) 1901* ------------------------------------------------- 1902* 1903 MAXTYP = 26 1904 NTYPES = MIN( MAXTYP, NTYPES ) 1905 IF( NTYPES.LE.0 ) THEN 1906 WRITE( NOUT, FMT = 9990 )C3 1907 ELSE 1908 IF( TSTERR ) 1909 $ CALL ZERRGG( C3, NOUT ) 1910 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1911 CALL ZDRGES( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT, 1912 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 1913 $ A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ), 1914 $ DC( 1, 1 ), DC( 1, 2 ), WORK, LWORK, RWORK, 1915 $ RESULT, LOGWRK, INFO ) 1916* 1917 IF( INFO.NE.0 ) 1918 $ WRITE( NOUT, FMT = 9980 )'ZDRGES', INFO 1919 END IF 1920 WRITE( NOUT, FMT = 9973 ) 1921 GO TO 10 1922* 1923 ELSE IF( ZGX ) THEN 1924* 1925* ------------------------------------------------- 1926* ZGX Generalized Nonsymmetric Eigenvalue Problem 1927* ZGGESX (Schur form and condition numbers) 1928* ------------------------------------------------- 1929* 1930 MAXTYP = 5 1931 NTYPES = MAXTYP 1932 IF( NN.LT.0 ) THEN 1933 WRITE( NOUT, FMT = 9990 )C3 1934 ELSE 1935 IF( TSTERR ) 1936 $ CALL ZERRGG( C3, NOUT ) 1937 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1938 CALL ZDRGSX( NN, NCMAX, THRESH, NIN, NOUT, A( 1, 1 ), NMAX, 1939 $ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), A( 1, 5 ), 1940 $ A( 1, 6 ), DC( 1, 1 ), DC( 1, 2 ), C, 1941 $ NCMAX*NCMAX, S, WORK, LWORK, RWORK, IWORK, 1942 $ LIWORK, LOGWRK, INFO ) 1943 IF( INFO.NE.0 ) 1944 $ WRITE( NOUT, FMT = 9980 )'ZDRGSX', INFO 1945 END IF 1946 WRITE( NOUT, FMT = 9973 ) 1947 GO TO 10 1948* 1949 ELSE IF( LSAMEN( 3, C3, 'ZGV' ) ) THEN 1950* 1951* ------------------------------------------------- 1952* ZGV: Generalized Nonsymmetric Eigenvalue Problem 1953* ZGGEV (Eigenvalue/vector form) 1954* ------------------------------------------------- 1955* 1956 MAXTYP = 26 1957 NTYPES = MIN( MAXTYP, NTYPES ) 1958 IF( NTYPES.LE.0 ) THEN 1959 WRITE( NOUT, FMT = 9990 )C3 1960 ELSE 1961 IF( TSTERR ) 1962 $ CALL ZERRGG( C3, NOUT ) 1963 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1964 CALL ZDRGEV( NN, NVAL, MAXTYP, DOTYPE, ISEED, THRESH, NOUT, 1965 $ A( 1, 1 ), NMAX, A( 1, 2 ), A( 1, 3 ), 1966 $ A( 1, 4 ), A( 1, 7 ), NMAX, A( 1, 8 ), 1967 $ A( 1, 9 ), NMAX, DC( 1, 1 ), DC( 1, 2 ), 1968 $ DC( 1, 3 ), DC( 1, 4 ), WORK, LWORK, RWORK, 1969 $ RESULT, INFO ) 1970 IF( INFO.NE.0 ) 1971 $ WRITE( NOUT, FMT = 9980 )'ZDRGEV', INFO 1972 END IF 1973 WRITE( NOUT, FMT = 9973 ) 1974 GO TO 10 1975* 1976 ELSE IF( ZXV ) THEN 1977* 1978* ------------------------------------------------- 1979* ZXV: Generalized Nonsymmetric Eigenvalue Problem 1980* ZGGEVX (eigenvalue/vector with condition numbers) 1981* ------------------------------------------------- 1982* 1983 MAXTYP = 2 1984 NTYPES = MAXTYP 1985 IF( NN.LT.0 ) THEN 1986 WRITE( NOUT, FMT = 9990 )C3 1987 ELSE 1988 IF( TSTERR ) 1989 $ CALL ZERRGG( C3, NOUT ) 1990 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 1991 CALL ZDRGVX( NN, THRESH, NIN, NOUT, A( 1, 1 ), NMAX, 1992 $ A( 1, 2 ), A( 1, 3 ), A( 1, 4 ), DC( 1, 1 ), 1993 $ DC( 1, 2 ), A( 1, 5 ), A( 1, 6 ), IWORK( 1 ), 1994 $ IWORK( 2 ), DR( 1, 1 ), DR( 1, 2 ), DR( 1, 3 ), 1995 $ DR( 1, 4 ), DR( 1, 5 ), DR( 1, 6 ), WORK, 1996 $ LWORK, RWORK, IWORK( 3 ), LIWORK-2, RESULT, 1997 $ LOGWRK, INFO ) 1998* 1999 IF( INFO.NE.0 ) 2000 $ WRITE( NOUT, FMT = 9980 )'ZDRGVX', INFO 2001 END IF 2002 WRITE( NOUT, FMT = 9973 ) 2003 GO TO 10 2004* 2005 ELSE IF( LSAMEN( 3, C3, 'ZHB' ) ) THEN 2006* 2007* ------------------------------ 2008* ZHB: Hermitian Band Reduction 2009* ------------------------------ 2010* 2011 MAXTYP = 15 2012 NTYPES = MIN( MAXTYP, NTYPES ) 2013 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 2014 IF( TSTERR ) 2015 $ CALL ZERRST( 'ZHB', NOUT ) 2016 CALL ZCHKHB( NN, NVAL, NK, KVAL, MAXTYP, DOTYPE, ISEED, THRESH, 2017 $ NOUT, A( 1, 1 ), NMAX, DR( 1, 1 ), DR( 1, 2 ), 2018 $ A( 1, 2 ), NMAX, WORK, LWORK, RWORK, RESULT, 2019 $ INFO ) 2020 IF( INFO.NE.0 ) 2021 $ WRITE( NOUT, FMT = 9980 )'ZCHKHB', INFO 2022* 2023 ELSE IF( LSAMEN( 3, C3, 'ZBB' ) ) THEN 2024* 2025* ------------------------------ 2026* ZBB: General Band Reduction 2027* ------------------------------ 2028* 2029 MAXTYP = 15 2030 NTYPES = MIN( MAXTYP, NTYPES ) 2031 CALL ALAREQ( C3, NTYPES, DOTYPE, MAXTYP, NIN, NOUT ) 2032 DO 370 I = 1, NPARMS 2033 NRHS = NSVAL( I ) 2034* 2035 IF( NEWSD.EQ.0 ) THEN 2036 DO 360 K = 1, 4 2037 ISEED( K ) = IOLDSD( K ) 2038 360 CONTINUE 2039 END IF 2040 WRITE( NOUT, FMT = 9966 )C3, NRHS 2041 CALL ZCHKBB( NN, MVAL, NVAL, NK, KVAL, MAXTYP, DOTYPE, NRHS, 2042 $ ISEED, THRESH, NOUT, A( 1, 1 ), NMAX, 2043 $ A( 1, 2 ), 2*NMAX, DR( 1, 1 ), DR( 1, 2 ), 2044 $ A( 1, 4 ), NMAX, A( 1, 5 ), NMAX, A( 1, 6 ), 2045 $ NMAX, A( 1, 7 ), WORK, LWORK, RWORK, RESULT, 2046 $ INFO ) 2047 IF( INFO.NE.0 ) 2048 $ WRITE( NOUT, FMT = 9980 )'ZCHKBB', INFO 2049 370 CONTINUE 2050* 2051 ELSE IF( LSAMEN( 3, C3, 'GLM' ) ) THEN 2052* 2053* ----------------------------------------- 2054* GLM: Generalized Linear Regression Model 2055* ----------------------------------------- 2056* 2057 IF( TSTERR ) 2058 $ CALL ZERRGG( 'GLM', NOUT ) 2059 CALL ZCKGLM( NN, NVAL, MVAL, PVAL, NTYPES, ISEED, THRESH, NMAX, 2060 $ A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X, 2061 $ WORK, DR( 1, 1 ), NIN, NOUT, INFO ) 2062 IF( INFO.NE.0 ) 2063 $ WRITE( NOUT, FMT = 9980 )'ZCKGLM', INFO 2064* 2065 ELSE IF( LSAMEN( 3, C3, 'GQR' ) ) THEN 2066* 2067* ------------------------------------------ 2068* GQR: Generalized QR and RQ factorizations 2069* ------------------------------------------ 2070* 2071 IF( TSTERR ) 2072 $ CALL ZERRGG( 'GQR', NOUT ) 2073 CALL ZCKGQR( NN, MVAL, NN, PVAL, NN, NVAL, NTYPES, ISEED, 2074 $ THRESH, NMAX, A( 1, 1 ), A( 1, 2 ), A( 1, 3 ), 2075 $ A( 1, 4 ), TAUA, B( 1, 1 ), B( 1, 2 ), B( 1, 3 ), 2076 $ B( 1, 4 ), B( 1, 5 ), TAUB, WORK, DR( 1, 1 ), NIN, 2077 $ NOUT, INFO ) 2078 IF( INFO.NE.0 ) 2079 $ WRITE( NOUT, FMT = 9980 )'ZCKGQR', INFO 2080* 2081 ELSE IF( LSAMEN( 3, C3, 'GSV' ) ) THEN 2082* 2083* ---------------------------------------------- 2084* GSV: Generalized Singular Value Decomposition 2085* ---------------------------------------------- 2086* 2087 IF( TSTERR ) 2088 $ CALL ZERRGG( 'GSV', NOUT ) 2089 CALL ZCKGSV( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX, 2090 $ A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), 2091 $ A( 1, 3 ), B( 1, 3 ), A( 1, 4 ), ALPHA, BETA, 2092 $ B( 1, 4 ), IWORK, WORK, DR( 1, 1 ), NIN, NOUT, 2093 $ INFO ) 2094 IF( INFO.NE.0 ) 2095 $ WRITE( NOUT, FMT = 9980 )'ZCKGSV', INFO 2096* 2097 ELSE IF( LSAMEN( 3, C3, 'LSE' ) ) THEN 2098* 2099* -------------------------------------- 2100* LSE: Constrained Linear Least Squares 2101* -------------------------------------- 2102* 2103 IF( TSTERR ) 2104 $ CALL ZERRGG( 'LSE', NOUT ) 2105 CALL ZCKLSE( NN, MVAL, PVAL, NVAL, NTYPES, ISEED, THRESH, NMAX, 2106 $ A( 1, 1 ), A( 1, 2 ), B( 1, 1 ), B( 1, 2 ), X, 2107 $ WORK, DR( 1, 1 ), NIN, NOUT, INFO ) 2108 IF( INFO.NE.0 ) 2109 $ WRITE( NOUT, FMT = 9980 )'ZCKLSE', INFO 2110 ELSE 2111 WRITE( NOUT, FMT = * ) 2112 WRITE( NOUT, FMT = * ) 2113 WRITE( NOUT, FMT = 9992 )C3 2114 END IF 2115 IF( .NOT.( ZGX .OR. ZXV ) ) 2116 $ GO TO 190 2117 380 CONTINUE 2118 WRITE( NOUT, FMT = 9994 ) 2119 S2 = DSECND( ) 2120 WRITE( NOUT, FMT = 9993 )S2 - S1 2121* 2122 9999 FORMAT( / ' Execution not attempted due to input errors' ) 2123 9998 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4, 2124 $ ', NS =', I4, ', MAXB =', I4 ) 2125 9997 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4 ) 2126 9996 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NS =', I4, 2127 $ ', MAXB =', I4, ', NBCOL =', I4 ) 2128 9995 FORMAT( / / 1X, A3, ': NB =', I4, ', NBMIN =', I4, ', NX =', I4, 2129 $ ', NRHS =', I4 ) 2130 9994 FORMAT( / / ' End of tests' ) 2131 9993 FORMAT( ' Total time used = ', F12.2, ' seconds', / ) 2132 9992 FORMAT( 1X, A3, ': Unrecognized path name' ) 2133 9991 FORMAT( / / ' *** Invalid integer value in column ', I2, 2134 $ ' of input', ' line:', / A79 ) 2135 9990 FORMAT( / / 1X, A3, ' routines were not tested' ) 2136 9989 FORMAT( ' Invalid input value: ', A6, '=', I6, '; must be >=', 2137 $ I6 ) 2138 9988 FORMAT( ' Invalid input value: ', A6, '=', I6, '; must be <=', 2139 $ I6 ) 2140 9987 FORMAT( ' Tests of the Nonsymmetric Eigenvalue Problem routines' ) 2141 9986 FORMAT( ' Tests of the Hermitian Eigenvalue Problem routines' ) 2142 9985 FORMAT( ' Tests of the Singular Value Decomposition routines' ) 2143 9984 FORMAT( / ' The following parameter values will be used:' ) 2144 9983 FORMAT( 4X, A6, 10I6, / 10X, 10I6 ) 2145 9982 FORMAT( / ' Routines pass computational tests if test ratio is ', 2146 $ 'less than', F8.2, / ) 2147 9981 FORMAT( ' Relative machine ', A, ' is taken to be', D16.6 ) 2148 9980 FORMAT( ' *** Error code from ', A6, ' = ', I4 ) 2149 9979 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver', 2150 $ / ' ZGEEV (eigenvalues and eigevectors)' ) 2151 9978 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Driver', 2152 $ / ' ZGEES (Schur form)' ) 2153 9977 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert', 2154 $ ' Driver', / ' ZGEEVX (eigenvalues, eigenvectors and', 2155 $ ' condition numbers)' ) 2156 9976 FORMAT( / ' Tests of the Nonsymmetric Eigenvalue Problem Expert', 2157 $ ' Driver', / ' ZGEESX (Schur form and condition', 2158 $ ' numbers)' ) 2159 9975 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 2160 $ 'Problem routines' ) 2161 9974 FORMAT( ' Tests of ZHBTRD', / ' (reduction of a Hermitian band ', 2162 $ 'matrix to real tridiagonal form)' ) 2163 9973 FORMAT( / 1X, 71( '-' ) ) 2164 9972 FORMAT( / ' LAPACK VERSION 3.0, released June 30, 1999 ' ) 2165 9971 FORMAT( / ' Tests of the Generalized Linear Regression Model ', 2166 $ 'routines' ) 2167 9970 FORMAT( / ' Tests of the Generalized QR and RQ routines' ) 2168 9969 FORMAT( / ' Tests of the Generalized Singular Value', 2169 $ ' Decomposition routines' ) 2170 9968 FORMAT( / ' Tests of the Linear Least Squares routines' ) 2171 9967 FORMAT( ' Tests of ZGBBRD', / ' (reduction of a general band ', 2172 $ 'matrix to real bidiagonal form)' ) 2173 9966 FORMAT( / / 1X, A3, ': NRHS =', I4 ) 2174 9965 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 2175 $ 'Problem Expert Driver ZGGESX' ) 2176 9964 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 2177 $ 'Problem Driver ZGGES' ) 2178 9963 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 2179 $ 'Problem Driver ZGGEV' ) 2180 9962 FORMAT( / ' Tests of the Generalized Nonsymmetric Eigenvalue ', 2181 $ 'Problem Expert Driver ZGGEVX' ) 2182* 2183* End of ZCHKEE 2184* 2185 END 2186