LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
ddrvgt.f
Go to the documentation of this file.
00001 *> \brief \b DDRVGT
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *  Definition:
00009 *  ===========
00010 *
00011 *       SUBROUTINE DDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF,
00012 *                          B, X, XACT, WORK, RWORK, IWORK, NOUT )
00013 * 
00014 *       .. Scalar Arguments ..
00015 *       LOGICAL            TSTERR
00016 *       INTEGER            NN, NOUT, NRHS
00017 *       DOUBLE PRECISION   THRESH
00018 *       ..
00019 *       .. Array Arguments ..
00020 *       LOGICAL            DOTYPE( * )
00021 *       INTEGER            IWORK( * ), NVAL( * )
00022 *       DOUBLE PRECISION   A( * ), AF( * ), B( * ), RWORK( * ), WORK( * ),
00023 *      $                   X( * ), XACT( * )
00024 *       ..
00025 *  
00026 *
00027 *> \par Purpose:
00028 *  =============
00029 *>
00030 *> \verbatim
00031 *>
00032 *> DDRVGT tests DGTSV and -SVX.
00033 *> \endverbatim
00034 *
00035 *  Arguments:
00036 *  ==========
00037 *
00038 *> \param[in] DOTYPE
00039 *> \verbatim
00040 *>          DOTYPE is LOGICAL array, dimension (NTYPES)
00041 *>          The matrix types to be used for testing.  Matrices of type j
00042 *>          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
00043 *>          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
00044 *> \endverbatim
00045 *>
00046 *> \param[in] NN
00047 *> \verbatim
00048 *>          NN is INTEGER
00049 *>          The number of values of N contained in the vector NVAL.
00050 *> \endverbatim
00051 *>
00052 *> \param[in] NVAL
00053 *> \verbatim
00054 *>          NVAL is INTEGER array, dimension (NN)
00055 *>          The values of the matrix dimension N.
00056 *> \endverbatim
00057 *>
00058 *> \param[in] NRHS
00059 *> \verbatim
00060 *>          NRHS is INTEGER
00061 *>          The number of right hand sides, NRHS >= 0.
00062 *> \endverbatim
00063 *>
00064 *> \param[in] THRESH
00065 *> \verbatim
00066 *>          THRESH is DOUBLE PRECISION
00067 *>          The threshold value for the test ratios.  A result is
00068 *>          included in the output file if RESULT >= THRESH.  To have
00069 *>          every test ratio printed, use THRESH = 0.
00070 *> \endverbatim
00071 *>
00072 *> \param[in] TSTERR
00073 *> \verbatim
00074 *>          TSTERR is LOGICAL
00075 *>          Flag that indicates whether error exits are to be tested.
00076 *> \endverbatim
00077 *>
00078 *> \param[out] A
00079 *> \verbatim
00080 *>          A is DOUBLE PRECISION array, dimension (NMAX*4)
00081 *> \endverbatim
00082 *>
00083 *> \param[out] AF
00084 *> \verbatim
00085 *>          AF is DOUBLE PRECISION array, dimension (NMAX*4)
00086 *> \endverbatim
00087 *>
00088 *> \param[out] B
00089 *> \verbatim
00090 *>          B is DOUBLE PRECISION array, dimension (NMAX*NRHS)
00091 *> \endverbatim
00092 *>
00093 *> \param[out] X
00094 *> \verbatim
00095 *>          X is DOUBLE PRECISION array, dimension (NMAX*NRHS)
00096 *> \endverbatim
00097 *>
00098 *> \param[out] XACT
00099 *> \verbatim
00100 *>          XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS)
00101 *> \endverbatim
00102 *>
00103 *> \param[out] WORK
00104 *> \verbatim
00105 *>          WORK is DOUBLE PRECISION array, dimension
00106 *>                      (NMAX*max(3,NRHS))
00107 *> \endverbatim
00108 *>
00109 *> \param[out] RWORK
00110 *> \verbatim
00111 *>          RWORK is DOUBLE PRECISION array, dimension
00112 *>                      (max(NMAX,2*NRHS))
00113 *> \endverbatim
00114 *>
00115 *> \param[out] IWORK
00116 *> \verbatim
00117 *>          IWORK is INTEGER array, dimension (2*NMAX)
00118 *> \endverbatim
00119 *>
00120 *> \param[in] NOUT
00121 *> \verbatim
00122 *>          NOUT is INTEGER
00123 *>          The unit number for output.
00124 *> \endverbatim
00125 *
00126 *  Authors:
00127 *  ========
00128 *
00129 *> \author Univ. of Tennessee 
00130 *> \author Univ. of California Berkeley 
00131 *> \author Univ. of Colorado Denver 
00132 *> \author NAG Ltd. 
00133 *
00134 *> \date November 2011
00135 *
00136 *> \ingroup double_lin
00137 *
00138 *  =====================================================================
00139       SUBROUTINE DDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF,
00140      $                   B, X, XACT, WORK, RWORK, IWORK, NOUT )
00141 *
00142 *  -- LAPACK test routine (version 3.4.0) --
00143 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00144 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00145 *     November 2011
00146 *
00147 *     .. Scalar Arguments ..
00148       LOGICAL            TSTERR
00149       INTEGER            NN, NOUT, NRHS
00150       DOUBLE PRECISION   THRESH
00151 *     ..
00152 *     .. Array Arguments ..
00153       LOGICAL            DOTYPE( * )
00154       INTEGER            IWORK( * ), NVAL( * )
00155       DOUBLE PRECISION   A( * ), AF( * ), B( * ), RWORK( * ), WORK( * ),
00156      $                   X( * ), XACT( * )
00157 *     ..
00158 *
00159 *  =====================================================================
00160 *
00161 *     .. Parameters ..
00162       DOUBLE PRECISION   ONE, ZERO
00163       PARAMETER          ( ONE = 1.0D+0, ZERO = 0.0D+0 )
00164       INTEGER            NTYPES
00165       PARAMETER          ( NTYPES = 12 )
00166       INTEGER            NTESTS
00167       PARAMETER          ( NTESTS = 6 )
00168 *     ..
00169 *     .. Local Scalars ..
00170       LOGICAL            TRFCON, ZEROT
00171       CHARACTER          DIST, FACT, TRANS, TYPE
00172       CHARACTER*3        PATH
00173       INTEGER            I, IFACT, IMAT, IN, INFO, ITRAN, IX, IZERO, J,
00174      $                   K, K1, KL, KOFF, KU, LDA, M, MODE, N, NERRS,
00175      $                   NFAIL, NIMAT, NRUN, NT
00176       DOUBLE PRECISION   AINVNM, ANORM, ANORMI, ANORMO, COND, RCOND,
00177      $                   RCONDC, RCONDI, RCONDO
00178 *     ..
00179 *     .. Local Arrays ..
00180       CHARACTER          TRANSS( 3 )
00181       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00182       DOUBLE PRECISION   RESULT( NTESTS ), Z( 3 )
00183 *     ..
00184 *     .. External Functions ..
00185       DOUBLE PRECISION   DASUM, DGET06, DLANGT
00186       EXTERNAL           DASUM, DGET06, DLANGT
00187 *     ..
00188 *     .. External Subroutines ..
00189       EXTERNAL           ALADHD, ALAERH, ALASVM, DCOPY, DERRVX, DGET04,
00190      $                   DGTSV, DGTSVX, DGTT01, DGTT02, DGTT05, DGTTRF,
00191      $                   DGTTRS, DLACPY, DLAGTM, DLARNV, DLASET, DLATB4,
00192      $                   DLATMS, DSCAL
00193 *     ..
00194 *     .. Intrinsic Functions ..
00195       INTRINSIC          MAX
00196 *     ..
00197 *     .. Scalars in Common ..
00198       LOGICAL            LERR, OK
00199       CHARACTER*32       SRNAMT
00200       INTEGER            INFOT, NUNIT
00201 *     ..
00202 *     .. Common blocks ..
00203       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
00204       COMMON             / SRNAMC / SRNAMT
00205 *     ..
00206 *     .. Data statements ..
00207       DATA               ISEEDY / 0, 0, 0, 1 / , TRANSS / 'N', 'T',
00208      $                   'C' /
00209 *     ..
00210 *     .. Executable Statements ..
00211 *
00212       PATH( 1: 1 ) = 'Double precision'
00213       PATH( 2: 3 ) = 'GT'
00214       NRUN = 0
00215       NFAIL = 0
00216       NERRS = 0
00217       DO 10 I = 1, 4
00218          ISEED( I ) = ISEEDY( I )
00219    10 CONTINUE
00220 *
00221 *     Test the error exits
00222 *
00223       IF( TSTERR )
00224      $   CALL DERRVX( PATH, NOUT )
00225       INFOT = 0
00226 *
00227       DO 140 IN = 1, NN
00228 *
00229 *        Do for each value of N in NVAL.
00230 *
00231          N = NVAL( IN )
00232          M = MAX( N-1, 0 )
00233          LDA = MAX( 1, N )
00234          NIMAT = NTYPES
00235          IF( N.LE.0 )
00236      $      NIMAT = 1
00237 *
00238          DO 130 IMAT = 1, NIMAT
00239 *
00240 *           Do the tests only if DOTYPE( IMAT ) is true.
00241 *
00242             IF( .NOT.DOTYPE( IMAT ) )
00243      $         GO TO 130
00244 *
00245 *           Set up parameters with DLATB4.
00246 *
00247             CALL DLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00248      $                   COND, DIST )
00249 *
00250             ZEROT = IMAT.GE.8 .AND. IMAT.LE.10
00251             IF( IMAT.LE.6 ) THEN
00252 *
00253 *              Types 1-6:  generate matrices of known condition number.
00254 *
00255                KOFF = MAX( 2-KU, 3-MAX( 1, N ) )
00256                SRNAMT = 'DLATMS'
00257                CALL DLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, COND,
00258      $                      ANORM, KL, KU, 'Z', AF( KOFF ), 3, WORK,
00259      $                      INFO )
00260 *
00261 *              Check the error code from DLATMS.
00262 *
00263                IF( INFO.NE.0 ) THEN
00264                   CALL ALAERH( PATH, 'DLATMS', INFO, 0, ' ', N, N, KL,
00265      $                         KU, -1, IMAT, NFAIL, NERRS, NOUT )
00266                   GO TO 130
00267                END IF
00268                IZERO = 0
00269 *
00270                IF( N.GT.1 ) THEN
00271                   CALL DCOPY( N-1, AF( 4 ), 3, A, 1 )
00272                   CALL DCOPY( N-1, AF( 3 ), 3, A( N+M+1 ), 1 )
00273                END IF
00274                CALL DCOPY( N, AF( 2 ), 3, A( M+1 ), 1 )
00275             ELSE
00276 *
00277 *              Types 7-12:  generate tridiagonal matrices with
00278 *              unknown condition numbers.
00279 *
00280                IF( .NOT.ZEROT .OR. .NOT.DOTYPE( 7 ) ) THEN
00281 *
00282 *                 Generate a matrix with elements from [-1,1].
00283 *
00284                   CALL DLARNV( 2, ISEED, N+2*M, A )
00285                   IF( ANORM.NE.ONE )
00286      $               CALL DSCAL( N+2*M, ANORM, A, 1 )
00287                ELSE IF( IZERO.GT.0 ) THEN
00288 *
00289 *                 Reuse the last matrix by copying back the zeroed out
00290 *                 elements.
00291 *
00292                   IF( IZERO.EQ.1 ) THEN
00293                      A( N ) = Z( 2 )
00294                      IF( N.GT.1 )
00295      $                  A( 1 ) = Z( 3 )
00296                   ELSE IF( IZERO.EQ.N ) THEN
00297                      A( 3*N-2 ) = Z( 1 )
00298                      A( 2*N-1 ) = Z( 2 )
00299                   ELSE
00300                      A( 2*N-2+IZERO ) = Z( 1 )
00301                      A( N-1+IZERO ) = Z( 2 )
00302                      A( IZERO ) = Z( 3 )
00303                   END IF
00304                END IF
00305 *
00306 *              If IMAT > 7, set one column of the matrix to 0.
00307 *
00308                IF( .NOT.ZEROT ) THEN
00309                   IZERO = 0
00310                ELSE IF( IMAT.EQ.8 ) THEN
00311                   IZERO = 1
00312                   Z( 2 ) = A( N )
00313                   A( N ) = ZERO
00314                   IF( N.GT.1 ) THEN
00315                      Z( 3 ) = A( 1 )
00316                      A( 1 ) = ZERO
00317                   END IF
00318                ELSE IF( IMAT.EQ.9 ) THEN
00319                   IZERO = N
00320                   Z( 1 ) = A( 3*N-2 )
00321                   Z( 2 ) = A( 2*N-1 )
00322                   A( 3*N-2 ) = ZERO
00323                   A( 2*N-1 ) = ZERO
00324                ELSE
00325                   IZERO = ( N+1 ) / 2
00326                   DO 20 I = IZERO, N - 1
00327                      A( 2*N-2+I ) = ZERO
00328                      A( N-1+I ) = ZERO
00329                      A( I ) = ZERO
00330    20             CONTINUE
00331                   A( 3*N-2 ) = ZERO
00332                   A( 2*N-1 ) = ZERO
00333                END IF
00334             END IF
00335 *
00336             DO 120 IFACT = 1, 2
00337                IF( IFACT.EQ.1 ) THEN
00338                   FACT = 'F'
00339                ELSE
00340                   FACT = 'N'
00341                END IF
00342 *
00343 *              Compute the condition number for comparison with
00344 *              the value returned by DGTSVX.
00345 *
00346                IF( ZEROT ) THEN
00347                   IF( IFACT.EQ.1 )
00348      $               GO TO 120
00349                   RCONDO = ZERO
00350                   RCONDI = ZERO
00351 *
00352                ELSE IF( IFACT.EQ.1 ) THEN
00353                   CALL DCOPY( N+2*M, A, 1, AF, 1 )
00354 *
00355 *                 Compute the 1-norm and infinity-norm of A.
00356 *
00357                   ANORMO = DLANGT( '1', N, A, A( M+1 ), A( N+M+1 ) )
00358                   ANORMI = DLANGT( 'I', N, A, A( M+1 ), A( N+M+1 ) )
00359 *
00360 *                 Factor the matrix A.
00361 *
00362                   CALL DGTTRF( N, AF, AF( M+1 ), AF( N+M+1 ),
00363      $                         AF( N+2*M+1 ), IWORK, INFO )
00364 *
00365 *                 Use DGTTRS to solve for one column at a time of
00366 *                 inv(A), computing the maximum column sum as we go.
00367 *
00368                   AINVNM = ZERO
00369                   DO 40 I = 1, N
00370                      DO 30 J = 1, N
00371                         X( J ) = ZERO
00372    30                CONTINUE
00373                      X( I ) = ONE
00374                      CALL DGTTRS( 'No transpose', N, 1, AF, AF( M+1 ),
00375      $                            AF( N+M+1 ), AF( N+2*M+1 ), IWORK, X,
00376      $                            LDA, INFO )
00377                      AINVNM = MAX( AINVNM, DASUM( N, X, 1 ) )
00378    40             CONTINUE
00379 *
00380 *                 Compute the 1-norm condition number of A.
00381 *
00382                   IF( ANORMO.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00383                      RCONDO = ONE
00384                   ELSE
00385                      RCONDO = ( ONE / ANORMO ) / AINVNM
00386                   END IF
00387 *
00388 *                 Use DGTTRS to solve for one column at a time of
00389 *                 inv(A'), computing the maximum column sum as we go.
00390 *
00391                   AINVNM = ZERO
00392                   DO 60 I = 1, N
00393                      DO 50 J = 1, N
00394                         X( J ) = ZERO
00395    50                CONTINUE
00396                      X( I ) = ONE
00397                      CALL DGTTRS( 'Transpose', N, 1, AF, AF( M+1 ),
00398      $                            AF( N+M+1 ), AF( N+2*M+1 ), IWORK, X,
00399      $                            LDA, INFO )
00400                      AINVNM = MAX( AINVNM, DASUM( N, X, 1 ) )
00401    60             CONTINUE
00402 *
00403 *                 Compute the infinity-norm condition number of A.
00404 *
00405                   IF( ANORMI.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00406                      RCONDI = ONE
00407                   ELSE
00408                      RCONDI = ( ONE / ANORMI ) / AINVNM
00409                   END IF
00410                END IF
00411 *
00412                DO 110 ITRAN = 1, 3
00413                   TRANS = TRANSS( ITRAN )
00414                   IF( ITRAN.EQ.1 ) THEN
00415                      RCONDC = RCONDO
00416                   ELSE
00417                      RCONDC = RCONDI
00418                   END IF
00419 *
00420 *                 Generate NRHS random solution vectors.
00421 *
00422                   IX = 1
00423                   DO 70 J = 1, NRHS
00424                      CALL DLARNV( 2, ISEED, N, XACT( IX ) )
00425                      IX = IX + LDA
00426    70             CONTINUE
00427 *
00428 *                 Set the right hand side.
00429 *
00430                   CALL DLAGTM( TRANS, N, NRHS, ONE, A, A( M+1 ),
00431      $                         A( N+M+1 ), XACT, LDA, ZERO, B, LDA )
00432 *
00433                   IF( IFACT.EQ.2 .AND. ITRAN.EQ.1 ) THEN
00434 *
00435 *                    --- Test DGTSV  ---
00436 *
00437 *                    Solve the system using Gaussian elimination with
00438 *                    partial pivoting.
00439 *
00440                      CALL DCOPY( N+2*M, A, 1, AF, 1 )
00441                      CALL DLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00442 *
00443                      SRNAMT = 'DGTSV '
00444                      CALL DGTSV( N, NRHS, AF, AF( M+1 ), AF( N+M+1 ), X,
00445      $                           LDA, INFO )
00446 *
00447 *                    Check error code from DGTSV .
00448 *
00449                      IF( INFO.NE.IZERO )
00450      $                  CALL ALAERH( PATH, 'DGTSV ', INFO, IZERO, ' ',
00451      $                               N, N, 1, 1, NRHS, IMAT, NFAIL,
00452      $                               NERRS, NOUT )
00453                      NT = 1
00454                      IF( IZERO.EQ.0 ) THEN
00455 *
00456 *                       Check residual of computed solution.
00457 *
00458                         CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK,
00459      $                               LDA )
00460                         CALL DGTT02( TRANS, N, NRHS, A, A( M+1 ),
00461      $                               A( N+M+1 ), X, LDA, WORK, LDA,
00462      $                               RESULT( 2 ) )
00463 *
00464 *                       Check solution from generated exact solution.
00465 *
00466                         CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00467      $                               RESULT( 3 ) )
00468                         NT = 3
00469                      END IF
00470 *
00471 *                    Print information about the tests that did not pass
00472 *                    the threshold.
00473 *
00474                      DO 80 K = 2, NT
00475                         IF( RESULT( K ).GE.THRESH ) THEN
00476                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00477      $                        CALL ALADHD( NOUT, PATH )
00478                            WRITE( NOUT, FMT = 9999 )'DGTSV ', N, IMAT,
00479      $                        K, RESULT( K )
00480                            NFAIL = NFAIL + 1
00481                         END IF
00482    80                CONTINUE
00483                      NRUN = NRUN + NT - 1
00484                   END IF
00485 *
00486 *                 --- Test DGTSVX ---
00487 *
00488                   IF( IFACT.GT.1 ) THEN
00489 *
00490 *                    Initialize AF to zero.
00491 *
00492                      DO 90 I = 1, 3*N - 2
00493                         AF( I ) = ZERO
00494    90                CONTINUE
00495                   END IF
00496                   CALL DLASET( 'Full', N, NRHS, ZERO, ZERO, X, LDA )
00497 *
00498 *                 Solve the system and compute the condition number and
00499 *                 error bounds using DGTSVX.
00500 *
00501                   SRNAMT = 'DGTSVX'
00502                   CALL DGTSVX( FACT, TRANS, N, NRHS, A, A( M+1 ),
00503      $                         A( N+M+1 ), AF, AF( M+1 ), AF( N+M+1 ),
00504      $                         AF( N+2*M+1 ), IWORK, B, LDA, X, LDA,
00505      $                         RCOND, RWORK, RWORK( NRHS+1 ), WORK,
00506      $                         IWORK( N+1 ), INFO )
00507 *
00508 *                 Check the error code from DGTSVX.
00509 *
00510                   IF( INFO.NE.IZERO )
00511      $               CALL ALAERH( PATH, 'DGTSVX', INFO, IZERO,
00512      $                            FACT // TRANS, N, N, 1, 1, NRHS, IMAT,
00513      $                            NFAIL, NERRS, NOUT )
00514 *
00515                   IF( IFACT.GE.2 ) THEN
00516 *
00517 *                    Reconstruct matrix from factors and compute
00518 *                    residual.
00519 *
00520                      CALL DGTT01( N, A, A( M+1 ), A( N+M+1 ), AF,
00521      $                            AF( M+1 ), AF( N+M+1 ), AF( N+2*M+1 ),
00522      $                            IWORK, WORK, LDA, RWORK, RESULT( 1 ) )
00523                      K1 = 1
00524                   ELSE
00525                      K1 = 2
00526                   END IF
00527 *
00528                   IF( INFO.EQ.0 ) THEN
00529                      TRFCON = .FALSE.
00530 *
00531 *                    Check residual of computed solution.
00532 *
00533                      CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
00534                      CALL DGTT02( TRANS, N, NRHS, A, A( M+1 ),
00535      $                            A( N+M+1 ), X, LDA, WORK, LDA,
00536      $                            RESULT( 2 ) )
00537 *
00538 *                    Check solution from generated exact solution.
00539 *
00540                      CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00541      $                            RESULT( 3 ) )
00542 *
00543 *                    Check the error bounds from iterative refinement.
00544 *
00545                      CALL DGTT05( TRANS, N, NRHS, A, A( M+1 ),
00546      $                            A( N+M+1 ), B, LDA, X, LDA, XACT, LDA,
00547      $                            RWORK, RWORK( NRHS+1 ), RESULT( 4 ) )
00548                      NT = 5
00549                   END IF
00550 *
00551 *                 Print information about the tests that did not pass
00552 *                 the threshold.
00553 *
00554                   DO 100 K = K1, NT
00555                      IF( RESULT( K ).GE.THRESH ) THEN
00556                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00557      $                     CALL ALADHD( NOUT, PATH )
00558                         WRITE( NOUT, FMT = 9998 )'DGTSVX', FACT, TRANS,
00559      $                     N, IMAT, K, RESULT( K )
00560                         NFAIL = NFAIL + 1
00561                      END IF
00562   100             CONTINUE
00563 *
00564 *                 Check the reciprocal of the condition number.
00565 *
00566                   RESULT( 6 ) = DGET06( RCOND, RCONDC )
00567                   IF( RESULT( 6 ).GE.THRESH ) THEN
00568                      IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00569      $                  CALL ALADHD( NOUT, PATH )
00570                      WRITE( NOUT, FMT = 9998 )'DGTSVX', FACT, TRANS, N,
00571      $                  IMAT, K, RESULT( K )
00572                      NFAIL = NFAIL + 1
00573                   END IF
00574                   NRUN = NRUN + NT - K1 + 2
00575 *
00576   110          CONTINUE
00577   120       CONTINUE
00578   130    CONTINUE
00579   140 CONTINUE
00580 *
00581 *     Print a summary of the results.
00582 *
00583       CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS )
00584 *
00585  9999 FORMAT( 1X, A, ', N =', I5, ', type ', I2, ', test ', I2,
00586      $      ', ratio = ', G12.5 )
00587  9998 FORMAT( 1X, A, ', FACT=''', A1, ''', TRANS=''', A1, ''', N =',
00588      $      I5, ', type ', I2, ', test ', I2, ', ratio = ', G12.5 )
00589       RETURN
00590 *
00591 *     End of DDRVGT
00592 *
00593       END
 All Files Functions