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