LAPACK: TESTING/LIN/zdrvge.f Source File

Go to the documentation of this file.
00001       SUBROUTINE ZDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
00002      $                   A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK,
00003      $                   RWORK, IWORK, NOUT )
00004 *
00005 *  -- LAPACK test routine (version 3.1) --
00006 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
00007 *     November 2006
00008 *
00009 *     .. Scalar Arguments ..
00010       LOGICAL            TSTERR
00011       INTEGER            NMAX, NN, NOUT, NRHS
00012       DOUBLE PRECISION   THRESH
00013 *     ..
00014 *     .. Array Arguments ..
00015       LOGICAL            DOTYPE( * )
00016       INTEGER            IWORK( * ), NVAL( * )
00017       DOUBLE PRECISION   RWORK( * ), S( * )
00018       COMPLEX*16         A( * ), AFAC( * ), ASAV( * ), B( * ),
00019      $                   BSAV( * ), WORK( * ), X( * ), XACT( * )
00020 *     ..
00021 *
00022 *  Purpose
00023 *  =======
00024 *
00025 *  ZDRVGE tests the driver routines ZGESV and -SVX.
00026 *
00027 *  Arguments
00028 *  =========
00029 *
00030 *  DOTYPE  (input) LOGICAL array, dimension (NTYPES)
00031 *          The matrix types to be used for testing.  Matrices of type j
00032 *          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
00033 *          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
00034 *
00035 *  NN      (input) INTEGER
00036 *          The number of values of N contained in the vector NVAL.
00037 *
00038 *  NVAL    (input) INTEGER array, dimension (NN)
00039 *          The values of the matrix column dimension N.
00040 *
00041 *  NRHS    (input) INTEGER
00042 *          The number of right hand side vectors to be generated for
00043 *          each linear system.
00044 *
00045 *  THRESH  (input) DOUBLE PRECISION
00046 *          The threshold value for the test ratios.  A result is
00047 *          included in the output file if RESULT >= THRESH.  To have
00048 *          every test ratio printed, use THRESH = 0.
00049 *
00050 *  TSTERR  (input) LOGICAL
00051 *          Flag that indicates whether error exits are to be tested.
00052 *
00053 *  NMAX    (input) INTEGER
00054 *          The maximum value permitted for N, used in dimensioning the
00055 *          work arrays.
00056 *
00057 *  A       (workspace) COMPLEX*16 array, dimension (NMAX*NMAX)
00058 *
00059 *  AFAC    (workspace) COMPLEX*16 array, dimension (NMAX*NMAX)
00060 *
00061 *  ASAV    (workspace) COMPLEX*16 array, dimension (NMAX*NMAX)
00062 *
00063 *  B       (workspace) COMPLEX*16 array, dimension (NMAX*NRHS)
00064 *
00065 *  BSAV    (workspace) COMPLEX*16 array, dimension (NMAX*NRHS)
00066 *
00067 *  X       (workspace) COMPLEX*16 array, dimension (NMAX*NRHS)
00068 *
00069 *  XACT    (workspace) COMPLEX*16 array, dimension (NMAX*NRHS)
00070 *
00071 *  S       (workspace) DOUBLE PRECISION array, dimension (2*NMAX)
00072 *
00073 *  WORK    (workspace) COMPLEX*16 array, dimension
00074 *                      (NMAX*max(3,NRHS))
00075 *
00076 *  RWORK   (workspace) DOUBLE PRECISION array, dimension (2*NRHS+NMAX)
00077 *
00078 *  IWORK   (workspace) INTEGER array, dimension (NMAX)
00079 *
00080 *  NOUT    (input) INTEGER
00081 *          The unit number for output.
00082 *
00083 *  =====================================================================
00084 *
00085 *     .. Parameters ..
00086       DOUBLE PRECISION   ONE, ZERO
00087       PARAMETER          ( ONE = 1.0D+0, ZERO = 0.0D+0 )
00088       INTEGER            NTYPES
00089       PARAMETER          ( NTYPES = 11 )
00090       INTEGER            NTESTS
00091       PARAMETER          ( NTESTS = 7 )
00092       INTEGER            NTRAN
00093       PARAMETER          ( NTRAN = 3 )
00094 *     ..
00095 *     .. Local Scalars ..
00096       LOGICAL            EQUIL, NOFACT, PREFAC, TRFCON, ZEROT
00097       CHARACTER          DIST, EQUED, FACT, TRANS, TYPE, XTYPE
00098       CHARACTER*3        PATH
00099       INTEGER            I, IEQUED, IFACT, IMAT, IN, INFO, IOFF, ITRAN,
00100      $                   IZERO, K, K1, KL, KU, LDA, LWORK, MODE, N, NB,
00101      $                   NBMIN, NERRS, NFACT, NFAIL, NIMAT, NRUN, NT
00102       DOUBLE PRECISION   AINVNM, AMAX, ANORM, ANORMI, ANORMO, CNDNUM,
00103      $                   COLCND, RCOND, RCONDC, RCONDI, RCONDO, ROLDC,
00104      $                   ROLDI, ROLDO, ROWCND, RPVGRW
00105 *     ..
00106 *     .. Local Arrays ..
00107       CHARACTER          EQUEDS( 4 ), FACTS( 3 ), TRANSS( NTRAN )
00108       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00109       DOUBLE PRECISION   RDUM( 1 ), RESULT( NTESTS )
00110 *     ..
00111 *     .. External Functions ..
00112       LOGICAL            LSAME
00113       DOUBLE PRECISION   DGET06, DLAMCH, ZLANGE, ZLANTR
00114       EXTERNAL           LSAME, DGET06, DLAMCH, ZLANGE, ZLANTR
00115 *     ..
00116 *     .. External Subroutines ..
00117       EXTERNAL           ALADHD, ALAERH, ALASVM, XLAENV, ZERRVX, ZGEEQU,
00118      $                   ZGESV, ZGESVX, ZGET01, ZGET02, ZGET04, ZGET07,
00119      $                   ZGETRF, ZGETRI, ZLACPY, ZLAQGE, ZLARHS, ZLASET,
00120      $                   ZLATB4, ZLATMS
00121 *     ..
00122 *     .. Intrinsic Functions ..
00123       INTRINSIC          ABS, DCMPLX, MAX
00124 *     ..
00125 *     .. Scalars in Common ..
00126       LOGICAL            LERR, OK
00127       CHARACTER*32       SRNAMT
00128       INTEGER            INFOT, NUNIT
00129 *     ..
00130 *     .. Common blocks ..
00131       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
00132       COMMON             / SRNAMC / SRNAMT
00133 *     ..
00134 *     .. Data statements ..
00135       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
00136       DATA               TRANSS / 'N', 'T', 'C' /
00137       DATA               FACTS / 'F', 'N', 'E' /
00138       DATA               EQUEDS / 'N', 'R', 'C', 'B' /
00139 *     ..
00140 *     .. Executable Statements ..
00141 *
00142 *     Initialize constants and the random number seed.
00143 *
00144       PATH( 1: 1 ) = 'Zomplex precision'
00145       PATH( 2: 3 ) = 'GE'
00146       NRUN = 0
00147       NFAIL = 0
00148       NERRS = 0
00149       DO 10 I = 1, 4
00150          ISEED( I ) = ISEEDY( I )
00151    10 CONTINUE
00152 *
00153 *     Test the error exits
00154 *
00155       IF( TSTERR )
00156      $   CALL ZERRVX( PATH, NOUT )
00157       INFOT = 0
00158 *
00159 *     Set the block size and minimum block size for testing.
00160 *
00161       NB = 1
00162       NBMIN = 2
00163       CALL XLAENV( 1, NB )
00164       CALL XLAENV( 2, NBMIN )
00165 *
00166 *     Do for each value of N in NVAL
00167 *
00168       DO 90 IN = 1, NN
00169          N = NVAL( IN )
00170          LDA = MAX( N, 1 )
00171          XTYPE = 'N'
00172          NIMAT = NTYPES
00173          IF( N.LE.0 )
00174      $      NIMAT = 1
00175 *
00176          DO 80 IMAT = 1, NIMAT
00177 *
00178 *           Do the tests only if DOTYPE( IMAT ) is true.
00179 *
00180             IF( .NOT.DOTYPE( IMAT ) )
00181      $         GO TO 80
00182 *
00183 *           Skip types 5, 6, or 7 if the matrix size is too small.
00184 *
00185             ZEROT = IMAT.GE.5 .AND. IMAT.LE.7
00186             IF( ZEROT .AND. N.LT.IMAT-4 )
00187      $         GO TO 80
00188 *
00189 *           Set up parameters with ZLATB4 and generate a test matrix
00190 *           with ZLATMS.
00191 *
00192             CALL ZLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00193      $                   CNDNUM, DIST )
00194             RCONDC = ONE / CNDNUM
00195 *
00196             SRNAMT = 'ZLATMS'
00197             CALL ZLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, CNDNUM,
00198      $                   ANORM, KL, KU, 'No packing', A, LDA, WORK,
00199      $                   INFO )
00200 *
00201 *           Check error code from ZLATMS.
00202 *
00203             IF( INFO.NE.0 ) THEN
00204                CALL ALAERH( PATH, 'ZLATMS', INFO, 0, ' ', N, N, -1, -1,
00205      $                      -1, IMAT, NFAIL, NERRS, NOUT )
00206                GO TO 80
00207             END IF
00208 *
00209 *           For types 5-7, zero one or more columns of the matrix to
00210 *           test that INFO is returned correctly.
00211 *
00212             IF( ZEROT ) THEN
00213                IF( IMAT.EQ.5 ) THEN
00214                   IZERO = 1
00215                ELSE IF( IMAT.EQ.6 ) THEN
00216                   IZERO = N
00217                ELSE
00218                   IZERO = N / 2 + 1
00219                END IF
00220                IOFF = ( IZERO-1 )*LDA
00221                IF( IMAT.LT.7 ) THEN
00222                   DO 20 I = 1, N
00223                      A( IOFF+I ) = ZERO
00224    20             CONTINUE
00225                ELSE
00226                   CALL ZLASET( 'Full', N, N-IZERO+1, DCMPLX( ZERO ),
00227      $                         DCMPLX( ZERO ), A( IOFF+1 ), LDA )
00228                END IF
00229             ELSE
00230                IZERO = 0
00231             END IF
00232 *
00233 *           Save a copy of the matrix A in ASAV.
00234 *
00235             CALL ZLACPY( 'Full', N, N, A, LDA, ASAV, LDA )
00236 *
00237             DO 70 IEQUED = 1, 4
00238                EQUED = EQUEDS( IEQUED )
00239                IF( IEQUED.EQ.1 ) THEN
00240                   NFACT = 3
00241                ELSE
00242                   NFACT = 1
00243                END IF
00244 *
00245                DO 60 IFACT = 1, NFACT
00246                   FACT = FACTS( IFACT )
00247                   PREFAC = LSAME( FACT, 'F' )
00248                   NOFACT = LSAME( FACT, 'N' )
00249                   EQUIL = LSAME( FACT, 'E' )
00250 *
00251                   IF( ZEROT ) THEN
00252                      IF( PREFAC )
00253      $                  GO TO 60
00254                      RCONDO = ZERO
00255                      RCONDI = ZERO
00256 *
00257                   ELSE IF( .NOT.NOFACT ) THEN
00258 *
00259 *                    Compute the condition number for comparison with
00260 *                    the value returned by ZGESVX (FACT = 'N' reuses
00261 *                    the condition number from the previous iteration
00262 *                    with FACT = 'F').
00263 *
00264                      CALL ZLACPY( 'Full', N, N, ASAV, LDA, AFAC, LDA )
00265                      IF( EQUIL .OR. IEQUED.GT.1 ) THEN
00266 *
00267 *                       Compute row and column scale factors to
00268 *                       equilibrate the matrix A.
00269 *
00270                         CALL ZGEEQU( N, N, AFAC, LDA, S, S( N+1 ),
00271      $                               ROWCND, COLCND, AMAX, INFO )
00272                         IF( INFO.EQ.0 .AND. N.GT.0 ) THEN
00273                            IF( LSAME( EQUED, 'R' ) ) THEN
00274                               ROWCND = ZERO
00275                               COLCND = ONE
00276                            ELSE IF( LSAME( EQUED, 'C' ) ) THEN
00277                               ROWCND = ONE
00278                               COLCND = ZERO
00279                            ELSE IF( LSAME( EQUED, 'B' ) ) THEN
00280                               ROWCND = ZERO
00281                               COLCND = ZERO
00282                            END IF
00283 *
00284 *                          Equilibrate the matrix.
00285 *
00286                            CALL ZLAQGE( N, N, AFAC, LDA, S, S( N+1 ),
00287      $                                  ROWCND, COLCND, AMAX, EQUED )
00288                         END IF
00289                      END IF
00290 *
00291 *                    Save the condition number of the non-equilibrated
00292 *                    system for use in ZGET04.
00293 *
00294                      IF( EQUIL ) THEN
00295                         ROLDO = RCONDO
00296                         ROLDI = RCONDI
00297                      END IF
00298 *
00299 *                    Compute the 1-norm and infinity-norm of A.
00300 *
00301                      ANORMO = ZLANGE( '1', N, N, AFAC, LDA, RWORK )
00302                      ANORMI = ZLANGE( 'I', N, N, AFAC, LDA, RWORK )
00303 *
00304 *                    Factor the matrix A.
00305 *
00306                      CALL ZGETRF( N, N, AFAC, LDA, IWORK, INFO )
00307 *
00308 *                    Form the inverse of A.
00309 *
00310                      CALL ZLACPY( 'Full', N, N, AFAC, LDA, A, LDA )
00311                      LWORK = NMAX*MAX( 3, NRHS )
00312                      CALL ZGETRI( N, A, LDA, IWORK, WORK, LWORK, INFO )
00313 *
00314 *                    Compute the 1-norm condition number of A.
00315 *
00316                      AINVNM = ZLANGE( '1', N, N, A, LDA, RWORK )
00317                      IF( ANORMO.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00318                         RCONDO = ONE
00319                      ELSE
00320                         RCONDO = ( ONE / ANORMO ) / AINVNM
00321                      END IF
00322 *
00323 *                    Compute the infinity-norm condition number of A.
00324 *
00325                      AINVNM = ZLANGE( 'I', N, N, A, LDA, RWORK )
00326                      IF( ANORMI.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00327                         RCONDI = ONE
00328                      ELSE
00329                         RCONDI = ( ONE / ANORMI ) / AINVNM
00330                      END IF
00331                   END IF
00332 *
00333                   DO 50 ITRAN = 1, NTRAN
00334 *
00335 *                    Do for each value of TRANS.
00336 *
00337                      TRANS = TRANSS( ITRAN )
00338                      IF( ITRAN.EQ.1 ) THEN
00339                         RCONDC = RCONDO
00340                      ELSE
00341                         RCONDC = RCONDI
00342                      END IF
00343 *
00344 *                    Restore the matrix A.
00345 *
00346                      CALL ZLACPY( 'Full', N, N, ASAV, LDA, A, LDA )
00347 *
00348 *                    Form an exact solution and set the right hand side.
00349 *
00350                      SRNAMT = 'ZLARHS'
00351                      CALL ZLARHS( PATH, XTYPE, 'Full', TRANS, N, N, KL,
00352      $                            KU, NRHS, A, LDA, XACT, LDA, B, LDA,
00353      $                            ISEED, INFO )
00354                      XTYPE = 'C'
00355                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, BSAV, LDA )
00356 *
00357                      IF( NOFACT .AND. ITRAN.EQ.1 ) THEN
00358 *
00359 *                       --- Test ZGESV  ---
00360 *
00361 *                       Compute the LU factorization of the matrix and
00362 *                       solve the system.
00363 *
00364                         CALL ZLACPY( 'Full', N, N, A, LDA, AFAC, LDA )
00365                         CALL ZLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00366 *
00367                         SRNAMT = 'ZGESV '
00368                         CALL ZGESV( N, NRHS, AFAC, LDA, IWORK, X, LDA,
00369      $                              INFO )
00370 *
00371 *                       Check error code from ZGESV .
00372 *
00373                         IF( INFO.NE.IZERO )
00374      $                     CALL ALAERH( PATH, 'ZGESV ', INFO, IZERO,
00375      $                                  ' ', N, N, -1, -1, NRHS, IMAT,
00376      $                                  NFAIL, NERRS, NOUT )
00377 *
00378 *                       Reconstruct matrix from factors and compute
00379 *                       residual.
00380 *
00381                         CALL ZGET01( N, N, A, LDA, AFAC, LDA, IWORK,
00382      $                               RWORK, RESULT( 1 ) )
00383                         NT = 1
00384                         IF( IZERO.EQ.0 ) THEN
00385 *
00386 *                          Compute residual of the computed solution.
00387 *
00388                            CALL ZLACPY( 'Full', N, NRHS, B, LDA, WORK,
00389      $                                  LDA )
00390                            CALL ZGET02( 'No transpose', N, N, NRHS, A,
00391      $                                  LDA, X, LDA, WORK, LDA, RWORK,
00392      $                                  RESULT( 2 ) )
00393 *
00394 *                          Check solution from generated exact solution.
00395 *
00396                            CALL ZGET04( N, NRHS, X, LDA, XACT, LDA,
00397      $                                  RCONDC, RESULT( 3 ) )
00398                            NT = 3
00399                         END IF
00400 *
00401 *                       Print information about the tests that did not
00402 *                       pass the threshold.
00403 *
00404                         DO 30 K = 1, NT
00405                            IF( RESULT( K ).GE.THRESH ) THEN
00406                               IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00407      $                           CALL ALADHD( NOUT, PATH )
00408                               WRITE( NOUT, FMT = 9999 )'ZGESV ', N,
00409      $                           IMAT, K, RESULT( K )
00410                               NFAIL = NFAIL + 1
00411                            END IF
00412    30                   CONTINUE
00413                         NRUN = NRUN + NT
00414                      END IF
00415 *
00416 *                    --- Test ZGESVX ---
00417 *
00418                      IF( .NOT.PREFAC )
00419      $                  CALL ZLASET( 'Full', N, N, DCMPLX( ZERO ),
00420      $                               DCMPLX( ZERO ), AFAC, LDA )
00421                      CALL ZLASET( 'Full', N, NRHS, DCMPLX( ZERO ),
00422      $                            DCMPLX( ZERO ), X, LDA )
00423                      IF( IEQUED.GT.1 .AND. N.GT.0 ) THEN
00424 *
00425 *                       Equilibrate the matrix if FACT = 'F' and
00426 *                       EQUED = 'R', 'C', or 'B'.
00427 *
00428                         CALL ZLAQGE( N, N, A, LDA, S, S( N+1 ), ROWCND,
00429      $                               COLCND, AMAX, EQUED )
00430                      END IF
00431 *
00432 *                    Solve the system and compute the condition number
00433 *                    and error bounds using ZGESVX.
00434 *
00435                      SRNAMT = 'ZGESVX'
00436                      CALL ZGESVX( FACT, TRANS, N, NRHS, A, LDA, AFAC,
00437      $                            LDA, IWORK, EQUED, S, S( N+1 ), B,
00438      $                            LDA, X, LDA, RCOND, RWORK,
00439      $                            RWORK( NRHS+1 ), WORK,
00440      $                            RWORK( 2*NRHS+1 ), INFO )
00441 *
00442 *                    Check the error code from ZGESVX.
00443 *
00444                      IF( INFO.NE.IZERO )
00445      $                  CALL ALAERH( PATH, 'ZGESVX', INFO, IZERO,
00446      $                               FACT // TRANS, N, N, -1, -1, NRHS,
00447      $                               IMAT, NFAIL, NERRS, NOUT )
00448 *
00449 *                    Compare RWORK(2*NRHS+1) from ZGESVX with the
00450 *                    computed reciprocal pivot growth factor RPVGRW
00451 *
00452                      IF( INFO.NE.0 ) THEN
00453                         RPVGRW = ZLANTR( 'M', 'U', 'N', INFO, INFO,
00454      $                           AFAC, LDA, RDUM )
00455                         IF( RPVGRW.EQ.ZERO ) THEN
00456                            RPVGRW = ONE
00457                         ELSE
00458                            RPVGRW = ZLANGE( 'M', N, INFO, A, LDA,
00459      $                              RDUM ) / RPVGRW
00460                         END IF
00461                      ELSE
00462                         RPVGRW = ZLANTR( 'M', 'U', 'N', N, N, AFAC, LDA,
00463      $                           RDUM )
00464                         IF( RPVGRW.EQ.ZERO ) THEN
00465                            RPVGRW = ONE
00466                         ELSE
00467                            RPVGRW = ZLANGE( 'M', N, N, A, LDA, RDUM ) /
00468      $                              RPVGRW
00469                         END IF
00470                      END IF
00471                      RESULT( 7 ) = ABS( RPVGRW-RWORK( 2*NRHS+1 ) ) /
00472      $                             MAX( RWORK( 2*NRHS+1 ), RPVGRW ) /
00473      $                             DLAMCH( 'E' )
00474 *
00475                      IF( .NOT.PREFAC ) THEN
00476 *
00477 *                       Reconstruct matrix from factors and compute
00478 *                       residual.
00479 *
00480                         CALL ZGET01( N, N, A, LDA, AFAC, LDA, IWORK,
00481      $                               RWORK( 2*NRHS+1 ), RESULT( 1 ) )
00482                         K1 = 1
00483                      ELSE
00484                         K1 = 2
00485                      END IF
00486 *
00487                      IF( INFO.EQ.0 ) THEN
00488                         TRFCON = .FALSE.
00489 *
00490 *                       Compute residual of the computed solution.
00491 *
00492                         CALL ZLACPY( 'Full', N, NRHS, BSAV, LDA, WORK,
00493      $                               LDA )
00494                         CALL ZGET02( TRANS, N, N, NRHS, ASAV, LDA, X,
00495      $                               LDA, WORK, LDA, RWORK( 2*NRHS+1 ),
00496      $                               RESULT( 2 ) )
00497 *
00498 *                       Check solution from generated exact solution.
00499 *
00500                         IF( NOFACT .OR. ( PREFAC .AND. LSAME( EQUED,
00501      $                      'N' ) ) ) THEN
00502                            CALL ZGET04( N, NRHS, X, LDA, XACT, LDA,
00503      $                                  RCONDC, RESULT( 3 ) )
00504                         ELSE
00505                            IF( ITRAN.EQ.1 ) THEN
00506                               ROLDC = ROLDO
00507                            ELSE
00508                               ROLDC = ROLDI
00509                            END IF
00510                            CALL ZGET04( N, NRHS, X, LDA, XACT, LDA,
00511      $                                  ROLDC, RESULT( 3 ) )
00512                         END IF
00513 *
00514 *                       Check the error bounds from iterative
00515 *                       refinement.
00516 *
00517                         CALL ZGET07( TRANS, N, NRHS, ASAV, LDA, B, LDA,
00518      $                               X, LDA, XACT, LDA, RWORK, .TRUE.,
00519      $                               RWORK( NRHS+1 ), RESULT( 4 ) )
00520                      ELSE
00521                         TRFCON = .TRUE.
00522                      END IF
00523 *
00524 *                    Compare RCOND from ZGESVX with the computed value
00525 *                    in RCONDC.
00526 *
00527                      RESULT( 6 ) = DGET06( RCOND, RCONDC )
00528 *
00529 *                    Print information about the tests that did not pass
00530 *                    the threshold.
00531 *
00532                      IF( .NOT.TRFCON ) THEN
00533                         DO 40 K = K1, NTESTS
00534                            IF( RESULT( K ).GE.THRESH ) THEN
00535                               IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00536      $                           CALL ALADHD( NOUT, PATH )
00537                               IF( PREFAC ) THEN
00538                                  WRITE( NOUT, FMT = 9997 )'ZGESVX',
00539      $                              FACT, TRANS, N, EQUED, IMAT, K,
00540      $                              RESULT( K )
00541                               ELSE
00542                                  WRITE( NOUT, FMT = 9998 )'ZGESVX',
00543      $                              FACT, TRANS, N, IMAT, K, RESULT( K )
00544                               END IF
00545                               NFAIL = NFAIL + 1
00546                            END IF
00547    40                   CONTINUE
00548                         NRUN = NRUN + 7 - K1
00549                      ELSE
00550                         IF( RESULT( 1 ).GE.THRESH .AND. .NOT.PREFAC )
00551      $                       THEN
00552                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00553      $                        CALL ALADHD( NOUT, PATH )
00554                            IF( PREFAC ) THEN
00555                               WRITE( NOUT, FMT = 9997 )'ZGESVX', FACT,
00556      $                           TRANS, N, EQUED, IMAT, 1, RESULT( 1 )
00557                            ELSE
00558                               WRITE( NOUT, FMT = 9998 )'ZGESVX', FACT,
00559      $                           TRANS, N, IMAT, 1, RESULT( 1 )
00560                            END IF
00561                            NFAIL = NFAIL + 1
00562                            NRUN = NRUN + 1
00563                         END IF
00564                         IF( RESULT( 6 ).GE.THRESH ) THEN
00565                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00566      $                        CALL ALADHD( NOUT, PATH )
00567                            IF( PREFAC ) THEN
00568                               WRITE( NOUT, FMT = 9997 )'ZGESVX', FACT,
00569      $                           TRANS, N, EQUED, IMAT, 6, RESULT( 6 )
00570                            ELSE
00571                               WRITE( NOUT, FMT = 9998 )'ZGESVX', FACT,
00572      $                           TRANS, N, IMAT, 6, RESULT( 6 )
00573                            END IF
00574                            NFAIL = NFAIL + 1
00575                            NRUN = NRUN + 1
00576                         END IF
00577                         IF( RESULT( 7 ).GE.THRESH ) THEN
00578                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00579      $                        CALL ALADHD( NOUT, PATH )
00580                            IF( PREFAC ) THEN
00581                               WRITE( NOUT, FMT = 9997 )'ZGESVX', FACT,
00582      $                           TRANS, N, EQUED, IMAT, 7, RESULT( 7 )
00583                            ELSE
00584                               WRITE( NOUT, FMT = 9998 )'ZGESVX', FACT,
00585      $                           TRANS, N, IMAT, 7, RESULT( 7 )
00586                            END IF
00587                            NFAIL = NFAIL + 1
00588                            NRUN = NRUN + 1
00589                         END IF
00590 *
00591                      END IF
00592 *
00593    50             CONTINUE
00594    60          CONTINUE
00595    70       CONTINUE
00596    80    CONTINUE
00597    90 CONTINUE
00598 *
00599 *     Print a summary of the results.
00600 *
00601       CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS )
00602 *
00603  9999 FORMAT( 1X, A, ', N =', I5, ', type ', I2, ', test(', I2, ') =',
00604      $      G12.5 )
00605  9998 FORMAT( 1X, A, ', FACT=''', A1, ''', TRANS=''', A1, ''', N=', I5,
00606      $      ', type ', I2, ', test(', I1, ')=', G12.5 )
00607  9997 FORMAT( 1X, A, ', FACT=''', A1, ''', TRANS=''', A1, ''', N=', I5,
00608      $      ', EQUED=''', A1, ''', type ', I2, ', test(', I1, ')=',
00609      $      G12.5 )
00610       RETURN
00611 *
00612 *     End of ZDRVGE
00613 *
00614       END