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