LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
cdrvpo.f
Go to the documentation of this file.
00001 *> \brief \b CDRVPO
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 CDRVPO( 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 *> CDRVPO tests the driver routines CPOSV 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)
00091 *> \endverbatim
00092 *>
00093 *> \param[out] AFAC
00094 *> \verbatim
00095 *>          AFAC is COMPLEX array, dimension (NMAX*NMAX)
00096 *> \endverbatim
00097 *>
00098 *> \param[out] ASAV
00099 *> \verbatim
00100 *>          ASAV is COMPLEX array, dimension (NMAX*NMAX)
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 CDRVPO( 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, 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, NB, NBMIN,
00196      $                   NERRS, NFACT, NFAIL, NIMAT, NRUN, NT
00197       REAL               AINVNM, AMAX, ANORM, CNDNUM, RCOND, RCONDC,
00198      $                   ROLDC, SCOND
00199 *     ..
00200 *     .. Local Arrays ..
00201       CHARACTER          EQUEDS( 2 ), FACTS( 3 ), UPLOS( 2 )
00202       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00203       REAL               RESULT( NTESTS )
00204 *     ..
00205 *     .. External Functions ..
00206       LOGICAL            LSAME
00207       REAL               CLANHE, SGET06
00208       EXTERNAL           LSAME, CLANHE, SGET06
00209 *     ..
00210 *     .. External Subroutines ..
00211       EXTERNAL           ALADHD, ALAERH, ALASVM, CERRVX, CGET04, CLACPY,
00212      $                   CLAIPD, CLAQHE, CLARHS, CLASET, CLATB4, CLATMS,
00213      $                   CPOEQU, CPOSV, CPOSVX, CPOT01, CPOT02, CPOT05,
00214      $                   CPOTRF, CPOTRI, XLAENV
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' /
00231       DATA               FACTS / 'F', 'N', 'E' /
00232       DATA               EQUEDS / 'N', 'Y' /
00233 *     ..
00234 *     .. Executable Statements ..
00235 *
00236 *     Initialize constants and the random number seed.
00237 *
00238       PATH( 1: 1 ) = 'Complex precision'
00239       PATH( 2: 3 ) = 'PO'
00240       NRUN = 0
00241       NFAIL = 0
00242       NERRS = 0
00243       DO 10 I = 1, 4
00244          ISEED( I ) = ISEEDY( I )
00245    10 CONTINUE
00246 *
00247 *     Test the error exits
00248 *
00249       IF( TSTERR )
00250      $   CALL CERRVX( PATH, NOUT )
00251       INFOT = 0
00252 *
00253 *     Set the block size and minimum block size for testing.
00254 *
00255       NB = 1
00256       NBMIN = 2
00257       CALL XLAENV( 1, NB )
00258       CALL XLAENV( 2, NBMIN )
00259 *
00260 *     Do for each value of N in NVAL
00261 *
00262       DO 130 IN = 1, NN
00263          N = NVAL( IN )
00264          LDA = MAX( N, 1 )
00265          XTYPE = 'N'
00266          NIMAT = NTYPES
00267          IF( N.LE.0 )
00268      $      NIMAT = 1
00269 *
00270          DO 120 IMAT = 1, NIMAT
00271 *
00272 *           Do the tests only if DOTYPE( IMAT ) is true.
00273 *
00274             IF( .NOT.DOTYPE( IMAT ) )
00275      $         GO TO 120
00276 *
00277 *           Skip types 3, 4, or 5 if the matrix size is too small.
00278 *
00279             ZEROT = IMAT.GE.3 .AND. IMAT.LE.5
00280             IF( ZEROT .AND. N.LT.IMAT-2 )
00281      $         GO TO 120
00282 *
00283 *           Do first for UPLO = 'U', then for UPLO = 'L'
00284 *
00285             DO 110 IUPLO = 1, 2
00286                UPLO = UPLOS( IUPLO )
00287 *
00288 *              Set up parameters with CLATB4 and generate a test matrix
00289 *              with CLATMS.
00290 *
00291                CALL CLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00292      $                      CNDNUM, DIST )
00293 *
00294                SRNAMT = 'CLATMS'
00295                CALL CLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
00296      $                      CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
00297      $                      INFO )
00298 *
00299 *              Check error code from CLATMS.
00300 *
00301                IF( INFO.NE.0 ) THEN
00302                   CALL ALAERH( PATH, 'CLATMS', INFO, 0, UPLO, N, N, -1,
00303      $                         -1, -1, IMAT, NFAIL, NERRS, NOUT )
00304                   GO TO 110
00305                END IF
00306 *
00307 *              For types 3-5, zero one row and column of the matrix to
00308 *              test that INFO is returned correctly.
00309 *
00310                IF( ZEROT ) THEN
00311                   IF( IMAT.EQ.3 ) THEN
00312                      IZERO = 1
00313                   ELSE IF( IMAT.EQ.4 ) THEN
00314                      IZERO = N
00315                   ELSE
00316                      IZERO = N / 2 + 1
00317                   END IF
00318                   IOFF = ( IZERO-1 )*LDA
00319 *
00320 *                 Set row and column IZERO of A to 0.
00321 *
00322                   IF( IUPLO.EQ.1 ) THEN
00323                      DO 20 I = 1, IZERO - 1
00324                         A( IOFF+I ) = ZERO
00325    20                CONTINUE
00326                      IOFF = IOFF + IZERO
00327                      DO 30 I = IZERO, N
00328                         A( IOFF ) = ZERO
00329                         IOFF = IOFF + LDA
00330    30                CONTINUE
00331                   ELSE
00332                      IOFF = IZERO
00333                      DO 40 I = 1, IZERO - 1
00334                         A( IOFF ) = ZERO
00335                         IOFF = IOFF + LDA
00336    40                CONTINUE
00337                      IOFF = IOFF - IZERO
00338                      DO 50 I = IZERO, N
00339                         A( IOFF+I ) = ZERO
00340    50                CONTINUE
00341                   END IF
00342                ELSE
00343                   IZERO = 0
00344                END IF
00345 *
00346 *              Set the imaginary part of the diagonals.
00347 *
00348                CALL CLAIPD( N, A, LDA+1, 0 )
00349 *
00350 *              Save a copy of the matrix A in ASAV.
00351 *
00352                CALL CLACPY( UPLO, N, N, A, LDA, ASAV, LDA )
00353 *
00354                DO 100 IEQUED = 1, 2
00355                   EQUED = EQUEDS( IEQUED )
00356                   IF( IEQUED.EQ.1 ) THEN
00357                      NFACT = 3
00358                   ELSE
00359                      NFACT = 1
00360                   END IF
00361 *
00362                   DO 90 IFACT = 1, NFACT
00363                      FACT = FACTS( IFACT )
00364                      PREFAC = LSAME( FACT, 'F' )
00365                      NOFACT = LSAME( FACT, 'N' )
00366                      EQUIL = LSAME( FACT, 'E' )
00367 *
00368                      IF( ZEROT ) THEN
00369                         IF( PREFAC )
00370      $                     GO TO 90
00371                         RCONDC = ZERO
00372 *
00373                      ELSE IF( .NOT.LSAME( FACT, 'N' ) ) THEN
00374 *
00375 *                       Compute the condition number for comparison with
00376 *                       the value returned by CPOSVX (FACT = 'N' reuses
00377 *                       the condition number from the previous iteration
00378 *                       with FACT = 'F').
00379 *
00380                         CALL CLACPY( UPLO, N, N, ASAV, LDA, AFAC, LDA )
00381                         IF( EQUIL .OR. IEQUED.GT.1 ) THEN
00382 *
00383 *                          Compute row and column scale factors to
00384 *                          equilibrate the matrix A.
00385 *
00386                            CALL CPOEQU( N, AFAC, LDA, S, SCOND, AMAX,
00387      $                                  INFO )
00388                            IF( INFO.EQ.0 .AND. N.GT.0 ) THEN
00389                               IF( IEQUED.GT.1 )
00390      $                           SCOND = ZERO
00391 *
00392 *                             Equilibrate the matrix.
00393 *
00394                               CALL CLAQHE( UPLO, N, AFAC, LDA, S, SCOND,
00395      $                                     AMAX, EQUED )
00396                            END IF
00397                         END IF
00398 *
00399 *                       Save the condition number of the
00400 *                       non-equilibrated system for use in CGET04.
00401 *
00402                         IF( EQUIL )
00403      $                     ROLDC = RCONDC
00404 *
00405 *                       Compute the 1-norm of A.
00406 *
00407                         ANORM = CLANHE( '1', UPLO, N, AFAC, LDA, RWORK )
00408 *
00409 *                       Factor the matrix A.
00410 *
00411                         CALL CPOTRF( UPLO, N, AFAC, LDA, INFO )
00412 *
00413 *                       Form the inverse of A.
00414 *
00415                         CALL CLACPY( UPLO, N, N, AFAC, LDA, A, LDA )
00416                         CALL CPOTRI( UPLO, N, A, LDA, INFO )
00417 *
00418 *                       Compute the 1-norm condition number of A.
00419 *
00420                         AINVNM = CLANHE( '1', UPLO, N, A, LDA, RWORK )
00421                         IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00422                            RCONDC = ONE
00423                         ELSE
00424                            RCONDC = ( ONE / ANORM ) / AINVNM
00425                         END IF
00426                      END IF
00427 *
00428 *                    Restore the matrix A.
00429 *
00430                      CALL CLACPY( UPLO, N, N, ASAV, LDA, A, LDA )
00431 *
00432 *                    Form an exact solution and set the right hand side.
00433 *
00434                      SRNAMT = 'CLARHS'
00435                      CALL CLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
00436      $                            NRHS, A, LDA, XACT, LDA, B, LDA,
00437      $                            ISEED, INFO )
00438                      XTYPE = 'C'
00439                      CALL CLACPY( 'Full', N, NRHS, B, LDA, BSAV, LDA )
00440 *
00441                      IF( NOFACT ) THEN
00442 *
00443 *                       --- Test CPOSV  ---
00444 *
00445 *                       Compute the L*L' or U'*U factorization of the
00446 *                       matrix and solve the system.
00447 *
00448                         CALL CLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
00449                         CALL CLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00450 *
00451                         SRNAMT = 'CPOSV '
00452                         CALL CPOSV( UPLO, N, NRHS, AFAC, LDA, X, LDA,
00453      $                              INFO )
00454 *
00455 *                       Check error code from CPOSV .
00456 *
00457                         IF( INFO.NE.IZERO ) THEN
00458                            CALL ALAERH( PATH, 'CPOSV ', INFO, IZERO,
00459      $                                  UPLO, N, N, -1, -1, NRHS, IMAT,
00460      $                                  NFAIL, NERRS, NOUT )
00461                            GO TO 70
00462                         ELSE IF( INFO.NE.0 ) THEN
00463                            GO TO 70
00464                         END IF
00465 *
00466 *                       Reconstruct matrix from factors and compute
00467 *                       residual.
00468 *
00469                         CALL CPOT01( UPLO, N, A, LDA, AFAC, LDA, RWORK,
00470      $                               RESULT( 1 ) )
00471 *
00472 *                       Compute residual of the computed solution.
00473 *
00474                         CALL CLACPY( 'Full', N, NRHS, B, LDA, WORK,
00475      $                               LDA )
00476                         CALL CPOT02( UPLO, N, NRHS, A, LDA, X, LDA,
00477      $                               WORK, LDA, RWORK, RESULT( 2 ) )
00478 *
00479 *                       Check solution from generated exact solution.
00480 *
00481                         CALL CGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00482      $                               RESULT( 3 ) )
00483                         NT = 3
00484 *
00485 *                       Print information about the tests that did not
00486 *                       pass the threshold.
00487 *
00488                         DO 60 K = 1, NT
00489                            IF( RESULT( K ).GE.THRESH ) THEN
00490                               IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00491      $                           CALL ALADHD( NOUT, PATH )
00492                               WRITE( NOUT, FMT = 9999 )'CPOSV ', UPLO,
00493      $                           N, IMAT, K, RESULT( K )
00494                               NFAIL = NFAIL + 1
00495                            END IF
00496    60                   CONTINUE
00497                         NRUN = NRUN + NT
00498    70                   CONTINUE
00499                      END IF
00500 *
00501 *                    --- Test CPOSVX ---
00502 *
00503                      IF( .NOT.PREFAC )
00504      $                  CALL CLASET( UPLO, N, N, CMPLX( ZERO ),
00505      $                               CMPLX( ZERO ), AFAC, LDA )
00506                      CALL CLASET( 'Full', N, NRHS, CMPLX( ZERO ),
00507      $                            CMPLX( ZERO ), X, LDA )
00508                      IF( IEQUED.GT.1 .AND. N.GT.0 ) THEN
00509 *
00510 *                       Equilibrate the matrix if FACT='F' and
00511 *                       EQUED='Y'.
00512 *
00513                         CALL CLAQHE( UPLO, N, A, LDA, S, SCOND, AMAX,
00514      $                               EQUED )
00515                      END IF
00516 *
00517 *                    Solve the system and compute the condition number
00518 *                    and error bounds using CPOSVX.
00519 *
00520                      SRNAMT = 'CPOSVX'
00521                      CALL CPOSVX( FACT, UPLO, N, NRHS, A, LDA, AFAC,
00522      $                            LDA, EQUED, S, B, LDA, X, LDA, RCOND,
00523      $                            RWORK, RWORK( NRHS+1 ), WORK,
00524      $                            RWORK( 2*NRHS+1 ), INFO )
00525 *
00526 *                    Check the error code from CPOSVX.
00527 *
00528                      IF( INFO.NE.IZERO ) THEN
00529                         CALL ALAERH( PATH, 'CPOSVX', INFO, IZERO,
00530      $                               FACT // UPLO, N, N, -1, -1, NRHS,
00531      $                               IMAT, NFAIL, NERRS, NOUT )
00532                         GO TO 90
00533                      END IF
00534 *
00535                      IF( INFO.EQ.0 ) THEN
00536                         IF( .NOT.PREFAC ) THEN
00537 *
00538 *                          Reconstruct matrix from factors and compute
00539 *                          residual.
00540 *
00541                            CALL CPOT01( UPLO, N, A, LDA, AFAC, LDA,
00542      $                                  RWORK( 2*NRHS+1 ), RESULT( 1 ) )
00543                            K1 = 1
00544                         ELSE
00545                            K1 = 2
00546                         END IF
00547 *
00548 *                       Compute residual of the computed solution.
00549 *
00550                         CALL CLACPY( 'Full', N, NRHS, BSAV, LDA, WORK,
00551      $                               LDA )
00552                         CALL CPOT02( UPLO, N, NRHS, ASAV, LDA, X, LDA,
00553      $                               WORK, LDA, RWORK( 2*NRHS+1 ),
00554      $                               RESULT( 2 ) )
00555 *
00556 *                       Check solution from generated exact solution.
00557 *
00558                         IF( NOFACT .OR. ( PREFAC .AND. LSAME( EQUED,
00559      $                      'N' ) ) ) THEN
00560                            CALL CGET04( N, NRHS, X, LDA, XACT, LDA,
00561      $                                  RCONDC, RESULT( 3 ) )
00562                         ELSE
00563                            CALL CGET04( N, NRHS, X, LDA, XACT, LDA,
00564      $                                  ROLDC, RESULT( 3 ) )
00565                         END IF
00566 *
00567 *                       Check the error bounds from iterative
00568 *                       refinement.
00569 *
00570                         CALL CPOT05( UPLO, N, NRHS, ASAV, LDA, B, LDA,
00571      $                               X, LDA, XACT, LDA, RWORK,
00572      $                               RWORK( NRHS+1 ), RESULT( 4 ) )
00573                      ELSE
00574                         K1 = 6
00575                      END IF
00576 *
00577 *                    Compare RCOND from CPOSVX with the computed value
00578 *                    in RCONDC.
00579 *
00580                      RESULT( 6 ) = SGET06( RCOND, RCONDC )
00581 *
00582 *                    Print information about the tests that did not pass
00583 *                    the threshold.
00584 *
00585                      DO 80 K = K1, 6
00586                         IF( RESULT( K ).GE.THRESH ) THEN
00587                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00588      $                        CALL ALADHD( NOUT, PATH )
00589                            IF( PREFAC ) THEN
00590                               WRITE( NOUT, FMT = 9997 )'CPOSVX', FACT,
00591      $                           UPLO, N, EQUED, IMAT, K, RESULT( K )
00592                            ELSE
00593                               WRITE( NOUT, FMT = 9998 )'CPOSVX', FACT,
00594      $                           UPLO, N, IMAT, K, RESULT( K )
00595                            END IF
00596                            NFAIL = NFAIL + 1
00597                         END IF
00598    80                CONTINUE
00599                      NRUN = NRUN + 7 - K1
00600    90             CONTINUE
00601   100          CONTINUE
00602   110       CONTINUE
00603   120    CONTINUE
00604   130 CONTINUE
00605 *
00606 *     Print a summary of the results.
00607 *
00608       CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS )
00609 *
00610  9999 FORMAT( 1X, A, ', UPLO=''', A1, ''', N =', I5, ', type ', I1,
00611      $      ', test(', I1, ')=', G12.5 )
00612  9998 FORMAT( 1X, A, ', FACT=''', A1, ''', UPLO=''', A1, ''', N=', I5,
00613      $      ', type ', I1, ', test(', I1, ')=', G12.5 )
00614  9997 FORMAT( 1X, A, ', FACT=''', A1, ''', UPLO=''', A1, ''', N=', I5,
00615      $      ', EQUED=''', A1, ''', type ', I1, ', test(', I1, ') =',
00616      $      G12.5 )
00617       RETURN
00618 *
00619 *     End of CDRVPO
00620 *
00621       END
 All Files Functions