1*> \brief \b SDRVGE 2* 3* =========== DOCUMENTATION =========== 4* 5* Online html documentation available at 6* http://www.netlib.org/lapack/explore-html/ 7* 8* Definition: 9* =========== 10* 11* SUBROUTINE SDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, 12* A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, 13* RWORK, IWORK, NOUT ) 14* 15* .. Scalar Arguments .. 16* LOGICAL TSTERR 17* INTEGER NMAX, NN, NOUT, NRHS 18* REAL THRESH 19* .. 20* .. Array Arguments .. 21* LOGICAL DOTYPE( * ) 22* INTEGER IWORK( * ), NVAL( * ) 23* REAL A( * ), AFAC( * ), ASAV( * ), B( * ), 24* $ BSAV( * ), RWORK( * ), S( * ), WORK( * ), 25* $ X( * ), XACT( * ) 26* .. 27* 28* 29*> \par Purpose: 30* ============= 31*> 32*> \verbatim 33*> 34*> SDRVGE tests the driver routines SGESV and -SVX. 35*> \endverbatim 36* 37* Arguments: 38* ========== 39* 40*> \param[in] DOTYPE 41*> \verbatim 42*> DOTYPE is LOGICAL array, dimension (NTYPES) 43*> The matrix types to be used for testing. Matrices of type j 44*> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = 45*> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 46*> \endverbatim 47*> 48*> \param[in] NN 49*> \verbatim 50*> NN is INTEGER 51*> The number of values of N contained in the vector NVAL. 52*> \endverbatim 53*> 54*> \param[in] NVAL 55*> \verbatim 56*> NVAL is INTEGER array, dimension (NN) 57*> The values of the matrix column dimension N. 58*> \endverbatim 59*> 60*> \param[in] NRHS 61*> \verbatim 62*> NRHS is INTEGER 63*> The number of right hand side vectors to be generated for 64*> each linear system. 65*> \endverbatim 66*> 67*> \param[in] THRESH 68*> \verbatim 69*> THRESH is REAL 70*> The threshold value for the test ratios. A result is 71*> included in the output file if RESULT >= THRESH. To have 72*> every test ratio printed, use THRESH = 0. 73*> \endverbatim 74*> 75*> \param[in] TSTERR 76*> \verbatim 77*> TSTERR is LOGICAL 78*> Flag that indicates whether error exits are to be tested. 79*> \endverbatim 80*> 81*> \param[in] NMAX 82*> \verbatim 83*> NMAX is INTEGER 84*> The maximum value permitted for N, used in dimensioning the 85*> work arrays. 86*> \endverbatim 87*> 88*> \param[out] A 89*> \verbatim 90*> A is REAL array, dimension (NMAX*NMAX) 91*> \endverbatim 92*> 93*> \param[out] AFAC 94*> \verbatim 95*> AFAC is REAL array, dimension (NMAX*NMAX) 96*> \endverbatim 97*> 98*> \param[out] ASAV 99*> \verbatim 100*> ASAV is REAL array, dimension (NMAX*NMAX) 101*> \endverbatim 102*> 103*> \param[out] B 104*> \verbatim 105*> B is REAL array, dimension (NMAX*NRHS) 106*> \endverbatim 107*> 108*> \param[out] BSAV 109*> \verbatim 110*> BSAV is REAL array, dimension (NMAX*NRHS) 111*> \endverbatim 112*> 113*> \param[out] X 114*> \verbatim 115*> X is REAL array, dimension (NMAX*NRHS) 116*> \endverbatim 117*> 118*> \param[out] XACT 119*> \verbatim 120*> XACT is REAL array, dimension (NMAX*NRHS) 121*> \endverbatim 122*> 123*> \param[out] S 124*> \verbatim 125*> S is REAL array, dimension (2*NMAX) 126*> \endverbatim 127*> 128*> \param[out] WORK 129*> \verbatim 130*> WORK is REAL array, dimension 131*> (NMAX*max(3,NRHS)) 132*> \endverbatim 133*> 134*> \param[out] RWORK 135*> \verbatim 136*> RWORK is REAL array, dimension (2*NRHS+NMAX) 137*> \endverbatim 138*> 139*> \param[out] IWORK 140*> \verbatim 141*> IWORK is INTEGER array, dimension (2*NMAX) 142*> \endverbatim 143*> 144*> \param[in] NOUT 145*> \verbatim 146*> NOUT is INTEGER 147*> The unit number for output. 148*> \endverbatim 149* 150* Authors: 151* ======== 152* 153*> \author Univ. of Tennessee 154*> \author Univ. of California Berkeley 155*> \author Univ. of Colorado Denver 156*> \author NAG Ltd. 157* 158*> \date November 2011 159* 160*> \ingroup single_lin 161* 162* ===================================================================== 163 SUBROUTINE SDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, 164 $ A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, 165 $ RWORK, IWORK, NOUT ) 166* 167* -- LAPACK test routine (version 3.4.0) -- 168* -- LAPACK is a software package provided by Univ. of Tennessee, -- 169* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 170* November 2011 171* 172* .. Scalar Arguments .. 173 LOGICAL TSTERR 174 INTEGER NMAX, NN, NOUT, NRHS 175 REAL THRESH 176* .. 177* .. Array Arguments .. 178 LOGICAL DOTYPE( * ) 179 INTEGER IWORK( * ), NVAL( * ) 180 REAL A( * ), AFAC( * ), ASAV( * ), B( * ), 181 $ BSAV( * ), RWORK( * ), S( * ), WORK( * ), 182 $ X( * ), XACT( * ) 183* .. 184* 185* ===================================================================== 186* 187* .. Parameters .. 188 REAL ONE, ZERO 189 PARAMETER ( ONE = 1.0E+0, ZERO = 0.0E+0 ) 190 INTEGER NTYPES 191 PARAMETER ( NTYPES = 11 ) 192 INTEGER NTESTS 193 PARAMETER ( NTESTS = 7 ) 194 INTEGER NTRAN 195 PARAMETER ( NTRAN = 3 ) 196* .. 197* .. Local Scalars .. 198 LOGICAL EQUIL, NOFACT, PREFAC, TRFCON, ZEROT 199 CHARACTER DIST, EQUED, FACT, TRANS, TYPE, XTYPE 200 CHARACTER*3 PATH 201 INTEGER I, IEQUED, IFACT, IMAT, IN, INFO, IOFF, ITRAN, 202 $ IZERO, K, K1, KL, KU, LDA, LWORK, MODE, N, NB, 203 $ NBMIN, NERRS, NFACT, NFAIL, NIMAT, NRUN, NT 204 REAL AINVNM, AMAX, ANORM, ANORMI, ANORMO, CNDNUM, 205 $ COLCND, RCOND, RCONDC, RCONDI, RCONDO, ROLDC, 206 $ ROLDI, ROLDO, ROWCND, RPVGRW 207* .. 208* .. Local Arrays .. 209 CHARACTER EQUEDS( 4 ), FACTS( 3 ), TRANSS( NTRAN ) 210 INTEGER ISEED( 4 ), ISEEDY( 4 ) 211 REAL RESULT( NTESTS ) 212* .. 213* .. External Functions .. 214 LOGICAL LSAME 215 REAL SGET06, SLAMCH, SLANGE, SLANTR 216 EXTERNAL LSAME, SGET06, SLAMCH, SLANGE, SLANTR 217* .. 218* .. External Subroutines .. 219 EXTERNAL ALADHD, ALAERH, ALASVM, SERRVX, SGEEQU, SGESV, 220 $ SGESVX, SGET01, SGET02, SGET04, SGET07, SGETRF, 221 $ SGETRI, SLACPY, SLAQGE, SLARHS, SLASET, SLATB4, 222 $ SLATMS, XLAENV 223* .. 224* .. Intrinsic Functions .. 225 INTRINSIC ABS, MAX 226* .. 227* .. Scalars in Common .. 228 LOGICAL LERR, OK 229 CHARACTER*32 SRNAMT 230 INTEGER INFOT, NUNIT 231* .. 232* .. Common blocks .. 233 COMMON / INFOC / INFOT, NUNIT, OK, LERR 234 COMMON / SRNAMC / SRNAMT 235* .. 236* .. Data statements .. 237 DATA ISEEDY / 1988, 1989, 1990, 1991 / 238 DATA TRANSS / 'N', 'T', 'C' / 239 DATA FACTS / 'F', 'N', 'E' / 240 DATA EQUEDS / 'N', 'R', 'C', 'B' / 241* .. 242* .. Executable Statements .. 243* 244* Initialize constants and the random number seed. 245* 246 PATH( 1: 1 ) = 'Single precision' 247 PATH( 2: 3 ) = 'GE' 248 NRUN = 0 249 NFAIL = 0 250 NERRS = 0 251 DO 10 I = 1, 4 252 ISEED( I ) = ISEEDY( I ) 253 10 CONTINUE 254* 255* Test the error exits 256* 257 IF( TSTERR ) 258 $ CALL SERRVX( PATH, NOUT ) 259 INFOT = 0 260* 261* Set the block size and minimum block size for testing. 262* 263 NB = 1 264 NBMIN = 2 265 CALL XLAENV( 1, NB ) 266 CALL XLAENV( 2, NBMIN ) 267* 268* Do for each value of N in NVAL 269* 270 DO 90 IN = 1, NN 271 N = NVAL( IN ) 272 LDA = MAX( N, 1 ) 273 XTYPE = 'N' 274 NIMAT = NTYPES 275 IF( N.LE.0 ) 276 $ NIMAT = 1 277* 278 DO 80 IMAT = 1, NIMAT 279* 280* Do the tests only if DOTYPE( IMAT ) is true. 281* 282 IF( .NOT.DOTYPE( IMAT ) ) 283 $ GO TO 80 284* 285* Skip types 5, 6, or 7 if the matrix size is too small. 286* 287 ZEROT = IMAT.GE.5 .AND. IMAT.LE.7 288 IF( ZEROT .AND. N.LT.IMAT-4 ) 289 $ GO TO 80 290* 291* Set up parameters with SLATB4 and generate a test matrix 292* with SLATMS. 293* 294 CALL SLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE, 295 $ CNDNUM, DIST ) 296 RCONDC = ONE / CNDNUM 297* 298 SRNAMT = 'SLATMS' 299 CALL SLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, CNDNUM, 300 $ ANORM, KL, KU, 'No packing', A, LDA, WORK, 301 $ INFO ) 302* 303* Check error code from SLATMS. 304* 305 IF( INFO.NE.0 ) THEN 306 CALL ALAERH( PATH, 'SLATMS', INFO, 0, ' ', N, N, -1, -1, 307 $ -1, IMAT, NFAIL, NERRS, NOUT ) 308 GO TO 80 309 END IF 310* 311* For types 5-7, zero one or more columns of the matrix to 312* test that INFO is returned correctly. 313* 314 IF( ZEROT ) THEN 315 IF( IMAT.EQ.5 ) THEN 316 IZERO = 1 317 ELSE IF( IMAT.EQ.6 ) THEN 318 IZERO = N 319 ELSE 320 IZERO = N / 2 + 1 321 END IF 322 IOFF = ( IZERO-1 )*LDA 323 IF( IMAT.LT.7 ) THEN 324 DO 20 I = 1, N 325 A( IOFF+I ) = ZERO 326 20 CONTINUE 327 ELSE 328 CALL SLASET( 'Full', N, N-IZERO+1, ZERO, ZERO, 329 $ A( IOFF+1 ), LDA ) 330 END IF 331 ELSE 332 IZERO = 0 333 END IF 334* 335* Save a copy of the matrix A in ASAV. 336* 337 CALL SLACPY( 'Full', N, N, A, LDA, ASAV, LDA ) 338* 339 DO 70 IEQUED = 1, 4 340 EQUED = EQUEDS( IEQUED ) 341 IF( IEQUED.EQ.1 ) THEN 342 NFACT = 3 343 ELSE 344 NFACT = 1 345 END IF 346* 347 DO 60 IFACT = 1, NFACT 348 FACT = FACTS( IFACT ) 349 PREFAC = LSAME( FACT, 'F' ) 350 NOFACT = LSAME( FACT, 'N' ) 351 EQUIL = LSAME( FACT, 'E' ) 352* 353 IF( ZEROT ) THEN 354 IF( PREFAC ) 355 $ GO TO 60 356 RCONDO = ZERO 357 RCONDI = ZERO 358* 359 ELSE IF( .NOT.NOFACT ) THEN 360* 361* Compute the condition number for comparison with 362* the value returned by SGESVX (FACT = 'N' reuses 363* the condition number from the previous iteration 364* with FACT = 'F'). 365* 366 CALL SLACPY( 'Full', N, N, ASAV, LDA, AFAC, LDA ) 367 IF( EQUIL .OR. IEQUED.GT.1 ) THEN 368* 369* Compute row and column scale factors to 370* equilibrate the matrix A. 371* 372 CALL SGEEQU( N, N, AFAC, LDA, S, S( N+1 ), 373 $ ROWCND, COLCND, AMAX, INFO ) 374 IF( INFO.EQ.0 .AND. N.GT.0 ) THEN 375 IF( LSAME( EQUED, 'R' ) ) THEN 376 ROWCND = ZERO 377 COLCND = ONE 378 ELSE IF( LSAME( EQUED, 'C' ) ) THEN 379 ROWCND = ONE 380 COLCND = ZERO 381 ELSE IF( LSAME( EQUED, 'B' ) ) THEN 382 ROWCND = ZERO 383 COLCND = ZERO 384 END IF 385* 386* Equilibrate the matrix. 387* 388 CALL SLAQGE( N, N, AFAC, LDA, S, S( N+1 ), 389 $ ROWCND, COLCND, AMAX, EQUED ) 390 END IF 391 END IF 392* 393* Save the condition number of the non-equilibrated 394* system for use in SGET04. 395* 396 IF( EQUIL ) THEN 397 ROLDO = RCONDO 398 ROLDI = RCONDI 399 END IF 400* 401* Compute the 1-norm and infinity-norm of A. 402* 403 ANORMO = SLANGE( '1', N, N, AFAC, LDA, RWORK ) 404 ANORMI = SLANGE( 'I', N, N, AFAC, LDA, RWORK ) 405* 406* Factor the matrix A. 407* 408 SRNAMT = 'SGETRF' 409 CALL SGETRF( N, N, AFAC, LDA, IWORK, INFO ) 410* 411* Form the inverse of A. 412* 413 CALL SLACPY( 'Full', N, N, AFAC, LDA, A, LDA ) 414 LWORK = NMAX*MAX( 3, NRHS ) 415 SRNAMT = 'SGETRI' 416 CALL SGETRI( N, A, LDA, IWORK, WORK, LWORK, INFO ) 417* 418* Compute the 1-norm condition number of A. 419* 420 AINVNM = SLANGE( '1', N, N, A, LDA, RWORK ) 421 IF( ANORMO.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 422 RCONDO = ONE 423 ELSE 424 RCONDO = ( ONE / ANORMO ) / AINVNM 425 END IF 426* 427* Compute the infinity-norm condition number of A. 428* 429 AINVNM = SLANGE( 'I', N, N, A, LDA, RWORK ) 430 IF( ANORMI.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 431 RCONDI = ONE 432 ELSE 433 RCONDI = ( ONE / ANORMI ) / AINVNM 434 END IF 435 END IF 436* 437 DO 50 ITRAN = 1, NTRAN 438* 439* Do for each value of TRANS. 440* 441 TRANS = TRANSS( ITRAN ) 442 IF( ITRAN.EQ.1 ) THEN 443 RCONDC = RCONDO 444 ELSE 445 RCONDC = RCONDI 446 END IF 447* 448* Restore the matrix A. 449* 450 CALL SLACPY( 'Full', N, N, ASAV, LDA, A, LDA ) 451* 452* Form an exact solution and set the right hand side. 453* 454 SRNAMT = 'SLARHS' 455 CALL SLARHS( PATH, XTYPE, 'Full', TRANS, N, N, KL, 456 $ KU, NRHS, A, LDA, XACT, LDA, B, LDA, 457 $ ISEED, INFO ) 458 XTYPE = 'C' 459 CALL SLACPY( 'Full', N, NRHS, B, LDA, BSAV, LDA ) 460* 461 IF( NOFACT .AND. ITRAN.EQ.1 ) THEN 462* 463* --- Test SGESV --- 464* 465* Compute the LU factorization of the matrix and 466* solve the system. 467* 468 CALL SLACPY( 'Full', N, N, A, LDA, AFAC, LDA ) 469 CALL SLACPY( 'Full', N, NRHS, B, LDA, X, LDA ) 470* 471 SRNAMT = 'SGESV ' 472 CALL SGESV( N, NRHS, AFAC, LDA, IWORK, X, LDA, 473 $ INFO ) 474* 475* Check error code from SGESV . 476* 477 IF( INFO.NE.IZERO ) 478 $ CALL ALAERH( PATH, 'SGESV ', INFO, IZERO, 479 $ ' ', N, N, -1, -1, NRHS, IMAT, 480 $ NFAIL, NERRS, NOUT ) 481* 482* Reconstruct matrix from factors and compute 483* residual. 484* 485 CALL SGET01( N, N, A, LDA, AFAC, LDA, IWORK, 486 $ RWORK, RESULT( 1 ) ) 487 NT = 1 488 IF( IZERO.EQ.0 ) THEN 489* 490* Compute residual of the computed solution. 491* 492 CALL SLACPY( 'Full', N, NRHS, B, LDA, WORK, 493 $ LDA ) 494 CALL SGET02( 'No transpose', N, N, NRHS, A, 495 $ LDA, X, LDA, WORK, LDA, RWORK, 496 $ RESULT( 2 ) ) 497* 498* Check solution from generated exact solution. 499* 500 CALL SGET04( N, NRHS, X, LDA, XACT, LDA, 501 $ RCONDC, RESULT( 3 ) ) 502 NT = 3 503 END IF 504* 505* Print information about the tests that did not 506* pass the threshold. 507* 508 DO 30 K = 1, NT 509 IF( RESULT( K ).GE.THRESH ) THEN 510 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 511 $ CALL ALADHD( NOUT, PATH ) 512 WRITE( NOUT, FMT = 9999 )'SGESV ', N, 513 $ IMAT, K, RESULT( K ) 514 NFAIL = NFAIL + 1 515 END IF 516 30 CONTINUE 517 NRUN = NRUN + NT 518 END IF 519* 520* --- Test SGESVX --- 521* 522 IF( .NOT.PREFAC ) 523 $ CALL SLASET( 'Full', N, N, ZERO, ZERO, AFAC, 524 $ LDA ) 525 CALL SLASET( 'Full', N, NRHS, ZERO, ZERO, X, LDA ) 526 IF( IEQUED.GT.1 .AND. N.GT.0 ) THEN 527* 528* Equilibrate the matrix if FACT = 'F' and 529* EQUED = 'R', 'C', or 'B'. 530* 531 CALL SLAQGE( N, N, A, LDA, S, S( N+1 ), ROWCND, 532 $ COLCND, AMAX, EQUED ) 533 END IF 534* 535* Solve the system and compute the condition number 536* and error bounds using SGESVX. 537* 538 SRNAMT = 'SGESVX' 539 CALL SGESVX( FACT, TRANS, N, NRHS, A, LDA, AFAC, 540 $ LDA, IWORK, EQUED, S, S( N+1 ), B, 541 $ LDA, X, LDA, RCOND, RWORK, 542 $ RWORK( NRHS+1 ), WORK, IWORK( N+1 ), 543 $ INFO ) 544* 545* Check the error code from SGESVX. 546* 547 IF( INFO.NE.IZERO ) 548 $ CALL ALAERH( PATH, 'SGESVX', INFO, IZERO, 549 $ FACT // TRANS, N, N, -1, -1, NRHS, 550 $ IMAT, NFAIL, NERRS, NOUT ) 551* 552* Compare WORK(1) from SGESVX with the computed 553* reciprocal pivot growth factor RPVGRW 554* 555 IF( INFO.NE.0 .AND. INFO.LE.N) THEN 556 RPVGRW = SLANTR( 'M', 'U', 'N', INFO, INFO, 557 $ AFAC, LDA, WORK ) 558 IF( RPVGRW.EQ.ZERO ) THEN 559 RPVGRW = ONE 560 ELSE 561 RPVGRW = SLANGE( 'M', N, INFO, A, LDA, 562 $ WORK ) / RPVGRW 563 END IF 564 ELSE 565 RPVGRW = SLANTR( 'M', 'U', 'N', N, N, AFAC, LDA, 566 $ WORK ) 567 IF( RPVGRW.EQ.ZERO ) THEN 568 RPVGRW = ONE 569 ELSE 570 RPVGRW = SLANGE( 'M', N, N, A, LDA, WORK ) / 571 $ RPVGRW 572 END IF 573 END IF 574 RESULT( 7 ) = ABS( RPVGRW-WORK( 1 ) ) / 575 $ MAX( WORK( 1 ), RPVGRW ) / 576 $ SLAMCH( 'E' ) 577* 578 IF( .NOT.PREFAC ) THEN 579* 580* Reconstruct matrix from factors and compute 581* residual. 582* 583 CALL SGET01( N, N, A, LDA, AFAC, LDA, IWORK, 584 $ RWORK( 2*NRHS+1 ), RESULT( 1 ) ) 585 K1 = 1 586 ELSE 587 K1 = 2 588 END IF 589* 590 IF( INFO.EQ.0 ) THEN 591 TRFCON = .FALSE. 592* 593* Compute residual of the computed solution. 594* 595 CALL SLACPY( 'Full', N, NRHS, BSAV, LDA, WORK, 596 $ LDA ) 597 CALL SGET02( TRANS, N, N, NRHS, ASAV, LDA, X, 598 $ LDA, WORK, LDA, RWORK( 2*NRHS+1 ), 599 $ RESULT( 2 ) ) 600* 601* Check solution from generated exact solution. 602* 603 IF( NOFACT .OR. ( PREFAC .AND. LSAME( EQUED, 604 $ 'N' ) ) ) THEN 605 CALL SGET04( N, NRHS, X, LDA, XACT, LDA, 606 $ RCONDC, RESULT( 3 ) ) 607 ELSE 608 IF( ITRAN.EQ.1 ) THEN 609 ROLDC = ROLDO 610 ELSE 611 ROLDC = ROLDI 612 END IF 613 CALL SGET04( N, NRHS, X, LDA, XACT, LDA, 614 $ ROLDC, RESULT( 3 ) ) 615 END IF 616* 617* Check the error bounds from iterative 618* refinement. 619* 620 CALL SGET07( TRANS, N, NRHS, ASAV, LDA, B, LDA, 621 $ X, LDA, XACT, LDA, RWORK, .TRUE., 622 $ RWORK( NRHS+1 ), RESULT( 4 ) ) 623 ELSE 624 TRFCON = .TRUE. 625 END IF 626* 627* Compare RCOND from SGESVX with the computed value 628* in RCONDC. 629* 630 RESULT( 6 ) = SGET06( RCOND, RCONDC ) 631* 632* Print information about the tests that did not pass 633* the threshold. 634* 635 IF( .NOT.TRFCON ) THEN 636 DO 40 K = K1, NTESTS 637 IF( RESULT( K ).GE.THRESH ) THEN 638 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 639 $ CALL ALADHD( NOUT, PATH ) 640 IF( PREFAC ) THEN 641 WRITE( NOUT, FMT = 9997 )'SGESVX', 642 $ FACT, TRANS, N, EQUED, IMAT, K, 643 $ RESULT( K ) 644 ELSE 645 WRITE( NOUT, FMT = 9998 )'SGESVX', 646 $ FACT, TRANS, N, IMAT, K, RESULT( K ) 647 END IF 648 NFAIL = NFAIL + 1 649 END IF 650 40 CONTINUE 651 NRUN = NRUN + 7 - K1 652 ELSE 653 IF( RESULT( 1 ).GE.THRESH .AND. .NOT.PREFAC ) 654 $ THEN 655 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 656 $ CALL ALADHD( NOUT, PATH ) 657 IF( PREFAC ) THEN 658 WRITE( NOUT, FMT = 9997 )'SGESVX', FACT, 659 $ TRANS, N, EQUED, IMAT, 1, RESULT( 1 ) 660 ELSE 661 WRITE( NOUT, FMT = 9998 )'SGESVX', FACT, 662 $ TRANS, N, IMAT, 1, RESULT( 1 ) 663 END IF 664 NFAIL = NFAIL + 1 665 NRUN = NRUN + 1 666 END IF 667 IF( RESULT( 6 ).GE.THRESH ) THEN 668 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 669 $ CALL ALADHD( NOUT, PATH ) 670 IF( PREFAC ) THEN 671 WRITE( NOUT, FMT = 9997 )'SGESVX', FACT, 672 $ TRANS, N, EQUED, IMAT, 6, RESULT( 6 ) 673 ELSE 674 WRITE( NOUT, FMT = 9998 )'SGESVX', FACT, 675 $ TRANS, N, IMAT, 6, RESULT( 6 ) 676 END IF 677 NFAIL = NFAIL + 1 678 NRUN = NRUN + 1 679 END IF 680 IF( RESULT( 7 ).GE.THRESH ) THEN 681 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 682 $ CALL ALADHD( NOUT, PATH ) 683 IF( PREFAC ) THEN 684 WRITE( NOUT, FMT = 9997 )'SGESVX', FACT, 685 $ TRANS, N, EQUED, IMAT, 7, RESULT( 7 ) 686 ELSE 687 WRITE( NOUT, FMT = 9998 )'SGESVX', FACT, 688 $ TRANS, N, IMAT, 7, RESULT( 7 ) 689 END IF 690 NFAIL = NFAIL + 1 691 NRUN = NRUN + 1 692 END IF 693* 694 END IF 695* 696 50 CONTINUE 697 60 CONTINUE 698 70 CONTINUE 699 80 CONTINUE 700 90 CONTINUE 701* 702* Print a summary of the results. 703* 704 CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS ) 705* 706 9999 FORMAT( 1X, A, ', N =', I5, ', type ', I2, ', test(', I2, ') =', 707 $ G12.5 ) 708 9998 FORMAT( 1X, A, ', FACT=''', A1, ''', TRANS=''', A1, ''', N=', I5, 709 $ ', type ', I2, ', test(', I1, ')=', G12.5 ) 710 9997 FORMAT( 1X, A, ', FACT=''', A1, ''', TRANS=''', A1, ''', N=', I5, 711 $ ', EQUED=''', A1, ''', type ', I2, ', test(', I1, ')=', 712 $ G12.5 ) 713 RETURN 714* 715* End of SDRVGE 716* 717 END 718