LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
cdrvrfp.f
Go to the documentation of this file.
00001 *> \brief \b CDRVRFP
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 CDRVRFP( NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL,
00012 *      +              THRESH, A, ASAV, AFAC, AINV, B,
00013 *      +              BSAV, XACT, X, ARF, ARFINV,
00014 *      +              C_WORK_CLATMS, C_WORK_CPOT02,
00015 *      +              C_WORK_CPOT03, S_WORK_CLATMS, S_WORK_CLANHE,
00016 *      +              S_WORK_CPOT01, S_WORK_CPOT02, S_WORK_CPOT03 )
00017 * 
00018 *       .. Scalar Arguments ..
00019 *       INTEGER            NN, NNS, NNT, NOUT
00020 *       REAL               THRESH
00021 *       ..
00022 *       .. Array Arguments ..
00023 *       INTEGER            NVAL( NN ), NSVAL( NNS ), NTVAL( NNT )
00024 *       COMPLEX            A( * )
00025 *       COMPLEX            AINV( * )
00026 *       COMPLEX            ASAV( * )
00027 *       COMPLEX            B( * )
00028 *       COMPLEX            BSAV( * )
00029 *       COMPLEX            AFAC( * )
00030 *       COMPLEX            ARF( * )
00031 *       COMPLEX            ARFINV( * )
00032 *       COMPLEX            XACT( * )
00033 *       COMPLEX            X( * )
00034 *       COMPLEX            C_WORK_CLATMS( * )
00035 *       COMPLEX            C_WORK_CPOT02( * )
00036 *       COMPLEX            C_WORK_CPOT03( * )
00037 *       REAL               S_WORK_CLATMS( * )
00038 *       REAL               S_WORK_CLANHE( * )
00039 *       REAL               S_WORK_CPOT01( * )
00040 *       REAL               S_WORK_CPOT02( * )
00041 *       REAL               S_WORK_CPOT03( * )
00042 *       ..
00043 *  
00044 *
00045 *> \par Purpose:
00046 *  =============
00047 *>
00048 *> \verbatim
00049 *>
00050 *> CDRVRFP tests the LAPACK RFP routines:
00051 *>     CPFTRF, CPFTRS, and CPFTRI.
00052 *>
00053 *> This testing routine follow the same tests as CDRVPO (test for the full
00054 *> format Symmetric Positive Definite solver).
00055 *>
00056 *> The tests are performed in Full Format, convertion back and forth from
00057 *> full format to RFP format are performed using the routines CTRTTF and
00058 *> CTFTTR.
00059 *>
00060 *> First, a specific matrix A of size N is created. There is nine types of 
00061 *> different matrixes possible.
00062 *>  1. Diagonal                        6. Random, CNDNUM = sqrt(0.1/EPS)
00063 *>  2. Random, CNDNUM = 2              7. Random, CNDNUM = 0.1/EPS
00064 *> *3. First row and column zero       8. Scaled near underflow
00065 *> *4. Last row and column zero        9. Scaled near overflow
00066 *> *5. Middle row and column zero
00067 *> (* - tests error exits from CPFTRF, no test ratios are computed)
00068 *> A solution XACT of size N-by-NRHS is created and the associated right
00069 *> hand side B as well. Then CPFTRF is called to compute L (or U), the
00070 *> Cholesky factor of A. Then L (or U) is used to solve the linear system
00071 *> of equations AX = B. This gives X. Then L (or U) is used to compute the
00072 *> inverse of A, AINV. The following four tests are then performed:
00073 *> (1) norm( L*L' - A ) / ( N * norm(A) * EPS ) or
00074 *>     norm( U'*U - A ) / ( N * norm(A) * EPS ),
00075 *> (2) norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
00076 *> (3) norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
00077 *> (4) ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
00078 *> where EPS is the machine precision, RCOND the condition number of A, and
00079 *> norm( . ) the 1-norm for (1,2,3) and the inf-norm for (4).
00080 *> Errors occur when INFO parameter is not as expected. Failures occur when
00081 *> a test ratios is greater than THRES.
00082 *> \endverbatim
00083 *
00084 *  Arguments:
00085 *  ==========
00086 *
00087 *> \param[in] NOUT
00088 *> \verbatim
00089 *>          NOUT is INTEGER
00090 *>                The unit number for output.
00091 *> \endverbatim
00092 *>
00093 *> \param[in] NN
00094 *> \verbatim
00095 *>          NN is INTEGER
00096 *>                The number of values of N contained in the vector NVAL.
00097 *> \endverbatim
00098 *>
00099 *> \param[in] NVAL
00100 *> \verbatim
00101 *>          NVAL is INTEGER array, dimension (NN)
00102 *>                The values of the matrix dimension N.
00103 *> \endverbatim
00104 *>
00105 *> \param[in] NNS
00106 *> \verbatim
00107 *>          NNS is INTEGER
00108 *>                The number of values of NRHS contained in the vector NSVAL.
00109 *> \endverbatim
00110 *>
00111 *> \param[in] NSVAL
00112 *> \verbatim
00113 *>          NSVAL is INTEGER array, dimension (NNS)
00114 *>                The values of the number of right-hand sides NRHS.
00115 *> \endverbatim
00116 *>
00117 *> \param[in] NNT
00118 *> \verbatim
00119 *>          NNT is INTEGER
00120 *>                The number of values of MATRIX TYPE contained in the vector NTVAL.
00121 *> \endverbatim
00122 *>
00123 *> \param[in] NTVAL
00124 *> \verbatim
00125 *>          NTVAL is INTEGER array, dimension (NNT)
00126 *>                The values of matrix type (between 0 and 9 for PO/PP/PF matrices).
00127 *> \endverbatim
00128 *>
00129 *> \param[in] THRESH
00130 *> \verbatim
00131 *>          THRESH is REAL
00132 *>                The threshold value for the test ratios.  A result is
00133 *>                included in the output file if RESULT >= THRESH.  To have
00134 *>                every test ratio printed, use THRESH = 0.
00135 *> \endverbatim
00136 *>
00137 *> \param[out] A
00138 *> \verbatim
00139 *>          A is COMPLEX array, dimension (NMAX*NMAX)
00140 *> \endverbatim
00141 *>
00142 *> \param[out] ASAV
00143 *> \verbatim
00144 *>          ASAV is COMPLEX array, dimension (NMAX*NMAX)
00145 *> \endverbatim
00146 *>
00147 *> \param[out] AFAC
00148 *> \verbatim
00149 *>          AFAC is COMPLEX array, dimension (NMAX*NMAX)
00150 *> \endverbatim
00151 *>
00152 *> \param[out] AINV
00153 *> \verbatim
00154 *>          AINV is COMPLEX array, dimension (NMAX*NMAX)
00155 *> \endverbatim
00156 *>
00157 *> \param[out] B
00158 *> \verbatim
00159 *>          B is COMPLEX array, dimension (NMAX*MAXRHS)
00160 *> \endverbatim
00161 *>
00162 *> \param[out] BSAV
00163 *> \verbatim
00164 *>          BSAV is COMPLEX array, dimension (NMAX*MAXRHS)
00165 *> \endverbatim
00166 *>
00167 *> \param[out] XACT
00168 *> \verbatim
00169 *>          XACT is COMPLEX array, dimension (NMAX*MAXRHS)
00170 *> \endverbatim
00171 *>
00172 *> \param[out] X
00173 *> \verbatim
00174 *>          X is COMPLEX array, dimension (NMAX*MAXRHS)
00175 *> \endverbatim
00176 *>
00177 *> \param[out] ARF
00178 *> \verbatim
00179 *>          ARF is COMPLEX array, dimension ((NMAX*(NMAX+1))/2)
00180 *> \endverbatim
00181 *>
00182 *> \param[out] ARFINV
00183 *> \verbatim
00184 *>          ARFINV is COMPLEX array, dimension ((NMAX*(NMAX+1))/2)
00185 *> \endverbatim
00186 *>
00187 *> \param[out] C_WORK_CLATMS
00188 *> \verbatim
00189 *>          C_WORK_CLATMS is COMPLEX array, dimension ( 3*NMAX )
00190 *> \endverbatim
00191 *>
00192 *> \param[out] C_WORK_CPOT02
00193 *> \verbatim
00194 *>          C_WORK_CPOT02 is COMPLEX array, dimension ( NMAX*MAXRHS )
00195 *> \endverbatim
00196 *>
00197 *> \param[out] C_WORK_CPOT03
00198 *> \verbatim
00199 *>          C_WORK_CPOT03 is COMPLEX array, dimension ( NMAX*NMAX )
00200 *> \endverbatim
00201 *>
00202 *> \param[out] S_WORK_CLATMS
00203 *> \verbatim
00204 *>          S_WORK_CLATMS is REAL array, dimension ( NMAX )
00205 *> \endverbatim
00206 *>
00207 *> \param[out] S_WORK_CLANHE
00208 *> \verbatim
00209 *>          S_WORK_CLANHE is REAL array, dimension ( NMAX )
00210 *> \endverbatim
00211 *>
00212 *> \param[out] S_WORK_CPOT01
00213 *> \verbatim
00214 *>          S_WORK_CPOT01 is REAL array, dimension ( NMAX )
00215 *> \endverbatim
00216 *>
00217 *> \param[out] S_WORK_CPOT02
00218 *> \verbatim
00219 *>          S_WORK_CPOT02 is REAL array, dimension ( NMAX )
00220 *> \endverbatim
00221 *>
00222 *> \param[out] S_WORK_CPOT03
00223 *> \verbatim
00224 *>          S_WORK_CPOT03 is REAL array, dimension ( NMAX )
00225 *> \endverbatim
00226 *
00227 *  Authors:
00228 *  ========
00229 *
00230 *> \author Univ. of Tennessee 
00231 *> \author Univ. of California Berkeley 
00232 *> \author Univ. of Colorado Denver 
00233 *> \author NAG Ltd. 
00234 *
00235 *> \date November 2011
00236 *
00237 *> \ingroup complex_lin
00238 *
00239 *  =====================================================================
00240       SUBROUTINE CDRVRFP( NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL,
00241      +              THRESH, A, ASAV, AFAC, AINV, B,
00242      +              BSAV, XACT, X, ARF, ARFINV,
00243      +              C_WORK_CLATMS, C_WORK_CPOT02,
00244      +              C_WORK_CPOT03, S_WORK_CLATMS, S_WORK_CLANHE,
00245      +              S_WORK_CPOT01, S_WORK_CPOT02, S_WORK_CPOT03 )
00246 *
00247 *  -- LAPACK test routine (version 3.4.0) --
00248 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00249 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00250 *     November 2011
00251 *
00252 *     .. Scalar Arguments ..
00253       INTEGER            NN, NNS, NNT, NOUT
00254       REAL               THRESH
00255 *     ..
00256 *     .. Array Arguments ..
00257       INTEGER            NVAL( NN ), NSVAL( NNS ), NTVAL( NNT )
00258       COMPLEX            A( * )
00259       COMPLEX            AINV( * )
00260       COMPLEX            ASAV( * )
00261       COMPLEX            B( * )
00262       COMPLEX            BSAV( * )
00263       COMPLEX            AFAC( * )
00264       COMPLEX            ARF( * )
00265       COMPLEX            ARFINV( * )
00266       COMPLEX            XACT( * )
00267       COMPLEX            X( * )
00268       COMPLEX            C_WORK_CLATMS( * )
00269       COMPLEX            C_WORK_CPOT02( * )
00270       COMPLEX            C_WORK_CPOT03( * )
00271       REAL               S_WORK_CLATMS( * )
00272       REAL               S_WORK_CLANHE( * )
00273       REAL               S_WORK_CPOT01( * )
00274       REAL               S_WORK_CPOT02( * )
00275       REAL               S_WORK_CPOT03( * )
00276 *     ..
00277 *
00278 *  =====================================================================
00279 *
00280 *     .. Parameters ..
00281       REAL               ONE, ZERO
00282       PARAMETER          ( ONE = 1.0E+0, ZERO = 0.0E+0 )
00283       INTEGER            NTESTS
00284       PARAMETER          ( NTESTS = 4 )
00285 *     ..
00286 *     .. Local Scalars ..
00287       LOGICAL            ZEROT
00288       INTEGER            I, INFO, IUPLO, LDA, LDB, IMAT, NERRS, NFAIL,
00289      +                   NRHS, NRUN, IZERO, IOFF, K, NT, N, IFORM, IIN,
00290      +                   IIT, IIS
00291       CHARACTER          DIST, CTYPE, UPLO, CFORM
00292       INTEGER            KL, KU, MODE
00293       REAL               ANORM, AINVNM, CNDNUM, RCONDC
00294 *     ..
00295 *     .. Local Arrays ..
00296       CHARACTER          UPLOS( 2 ), FORMS( 2 )
00297       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00298       REAL               RESULT( NTESTS )
00299 *     ..
00300 *     .. External Functions ..
00301       REAL               CLANHE
00302       EXTERNAL           CLANHE
00303 *     ..
00304 *     .. External Subroutines ..
00305       EXTERNAL           ALADHD, ALAERH, ALASVM, CGET04, CTFTTR, CLACPY,
00306      +                   CLAIPD, CLARHS, CLATB4, CLATMS, CPFTRI, CPFTRF,
00307      +                   CPFTRS, CPOT01, CPOT02, CPOT03, CPOTRI, CPOTRF,
00308      +                   CTRTTF
00309 *     ..
00310 *     .. Scalars in Common ..
00311       CHARACTER*32       SRNAMT
00312 *     ..
00313 *     .. Common blocks ..
00314       COMMON             / SRNAMC / SRNAMT
00315 *     ..
00316 *     .. Data statements ..
00317       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
00318       DATA               UPLOS / 'U', 'L' /
00319       DATA               FORMS / 'N', 'C' /
00320 *     ..
00321 *     .. Executable Statements ..
00322 *
00323 *     Initialize constants and the random number seed.
00324 *
00325       NRUN = 0
00326       NFAIL = 0
00327       NERRS = 0
00328       DO 10 I = 1, 4
00329          ISEED( I ) = ISEEDY( I )
00330    10 CONTINUE
00331 *
00332       DO 130 IIN = 1, NN
00333 *
00334          N = NVAL( IIN )
00335          LDA = MAX( N, 1 )
00336          LDB = MAX( N, 1 )
00337 *
00338          DO 980 IIS = 1, NNS
00339 *
00340             NRHS = NSVAL( IIS )
00341 *
00342             DO 120 IIT = 1, NNT
00343 *
00344                IMAT = NTVAL( IIT )
00345 *
00346 *              If N.EQ.0, only consider the first type
00347 *
00348                IF( N.EQ.0 .AND. IIT.GT.1 ) GO TO 120
00349 *
00350 *              Skip types 3, 4, or 5 if the matrix size is too small.
00351 *
00352                IF( IMAT.EQ.4 .AND. N.LE.1 ) GO TO 120
00353                IF( IMAT.EQ.5 .AND. N.LE.2 ) GO TO 120
00354 *
00355 *              Do first for UPLO = 'U', then for UPLO = 'L'
00356 *
00357                DO 110 IUPLO = 1, 2
00358                   UPLO = UPLOS( IUPLO )
00359 *
00360 *                 Do first for CFORM = 'N', then for CFORM = 'C'
00361 *
00362                   DO 100 IFORM = 1, 2
00363                      CFORM = FORMS( IFORM )
00364 *
00365 *                    Set up parameters with CLATB4 and generate a test
00366 *                    matrix with CLATMS.
00367 *
00368                      CALL CLATB4( 'CPO', IMAT, N, N, CTYPE, KL, KU,
00369      +                            ANORM, MODE, CNDNUM, DIST )
00370 *
00371                      SRNAMT = 'CLATMS'
00372                      CALL CLATMS( N, N, DIST, ISEED, CTYPE,
00373      +                            S_WORK_CLATMS,
00374      +                            MODE, CNDNUM, ANORM, KL, KU, UPLO, A,
00375      +                            LDA, C_WORK_CLATMS, INFO )
00376 *
00377 *                    Check error code from CLATMS.
00378 *
00379                      IF( INFO.NE.0 ) THEN
00380                         CALL ALAERH( 'CPF', 'CLATMS', INFO, 0, UPLO, N,
00381      +                               N, -1, -1, -1, IIT, NFAIL, NERRS,
00382      +                               NOUT )
00383                         GO TO 100
00384                      END IF
00385 *
00386 *                    For types 3-5, zero one row and column of the matrix to
00387 *                    test that INFO is returned correctly.
00388 *
00389                      ZEROT = IMAT.GE.3 .AND. IMAT.LE.5
00390                      IF( ZEROT ) THEN
00391                         IF( IIT.EQ.3 ) THEN
00392                            IZERO = 1
00393                         ELSE IF( IIT.EQ.4 ) THEN
00394                            IZERO = N
00395                         ELSE
00396                            IZERO = N / 2 + 1
00397                         END IF
00398                         IOFF = ( IZERO-1 )*LDA
00399 *
00400 *                       Set row and column IZERO of A to 0.
00401 *
00402                         IF( IUPLO.EQ.1 ) THEN
00403                            DO 20 I = 1, IZERO - 1
00404                               A( IOFF+I ) = ZERO
00405    20                      CONTINUE
00406                            IOFF = IOFF + IZERO
00407                            DO 30 I = IZERO, N
00408                               A( IOFF ) = ZERO
00409                               IOFF = IOFF + LDA
00410    30                      CONTINUE
00411                         ELSE
00412                            IOFF = IZERO
00413                            DO 40 I = 1, IZERO - 1
00414                               A( IOFF ) = ZERO
00415                               IOFF = IOFF + LDA
00416    40                      CONTINUE
00417                            IOFF = IOFF - IZERO
00418                            DO 50 I = IZERO, N
00419                               A( IOFF+I ) = ZERO
00420    50                      CONTINUE
00421                         END IF
00422                      ELSE
00423                         IZERO = 0
00424                      END IF
00425 *
00426 *                    Set the imaginary part of the diagonals.
00427 *
00428                      CALL CLAIPD( N, A, LDA+1, 0 )
00429 *
00430 *                    Save a copy of the matrix A in ASAV.
00431 *
00432                      CALL CLACPY( UPLO, N, N, A, LDA, ASAV, LDA )
00433 *
00434 *                    Compute the condition number of A (RCONDC).
00435 *
00436                      IF( ZEROT ) THEN
00437                         RCONDC = ZERO
00438                      ELSE
00439 *
00440 *                       Compute the 1-norm of A.
00441 *
00442                         ANORM = CLANHE( '1', UPLO, N, A, LDA,
00443      +                         S_WORK_CLANHE )
00444 *
00445 *                       Factor the matrix A.
00446 *
00447                         CALL CPOTRF( UPLO, N, A, LDA, INFO )
00448 *
00449 *                       Form the inverse of A.
00450 *
00451                         CALL CPOTRI( UPLO, N, A, LDA, INFO )
00452 *
00453 *                       Compute the 1-norm condition number of A.
00454 *
00455                         AINVNM = CLANHE( '1', UPLO, N, A, LDA,
00456      +                           S_WORK_CLANHE )
00457                         RCONDC = ( ONE / ANORM ) / AINVNM
00458 *
00459 *                       Restore the matrix A.
00460 *
00461                         CALL CLACPY( UPLO, N, N, ASAV, LDA, A, LDA )
00462 *
00463                      END IF
00464 *
00465 *                    Form an exact solution and set the right hand side.
00466 *
00467                      SRNAMT = 'CLARHS'
00468                      CALL CLARHS( 'CPO', 'N', UPLO, ' ', N, N, KL, KU,
00469      +                            NRHS, A, LDA, XACT, LDA, B, LDA,
00470      +                            ISEED, INFO )
00471                      CALL CLACPY( 'Full', N, NRHS, B, LDA, BSAV, LDA )
00472 *
00473 *                    Compute the L*L' or U'*U factorization of the
00474 *                    matrix and solve the system.
00475 *
00476                      CALL CLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
00477                      CALL CLACPY( 'Full', N, NRHS, B, LDB, X, LDB )
00478 *
00479                      SRNAMT = 'CTRTTF'
00480                      CALL CTRTTF( CFORM, UPLO, N, AFAC, LDA, ARF, INFO )
00481                      SRNAMT = 'CPFTRF'
00482                      CALL CPFTRF( CFORM, UPLO, N, ARF, INFO )
00483 *
00484 *                    Check error code from CPFTRF.
00485 *
00486                      IF( INFO.NE.IZERO ) THEN
00487 *
00488 *                       LANGOU: there is a small hick here: IZERO should
00489 *                       always be INFO however if INFO is ZERO, ALAERH does not
00490 *                       complain.
00491 *
00492                          CALL ALAERH( 'CPF', 'CPFSV ', INFO, IZERO,
00493      +                                UPLO, N, N, -1, -1, NRHS, IIT,
00494      +                                NFAIL, NERRS, NOUT )
00495                          GO TO 100
00496                       END IF
00497 *
00498 *                     Skip the tests if INFO is not 0.
00499 *
00500                      IF( INFO.NE.0 ) THEN
00501                         GO TO 100
00502                      END IF
00503 *
00504                      SRNAMT = 'CPFTRS'
00505                      CALL CPFTRS( CFORM, UPLO, N, NRHS, ARF, X, LDB,
00506      +                            INFO )
00507 *
00508                      SRNAMT = 'CTFTTR'
00509                      CALL CTFTTR( CFORM, UPLO, N, ARF, AFAC, LDA, INFO )
00510 *
00511 *                    Reconstruct matrix from factors and compute
00512 *                    residual.
00513 *
00514                      CALL CLACPY( UPLO, N, N, AFAC, LDA, ASAV, LDA )
00515                      CALL CPOT01( UPLO, N, A, LDA, AFAC, LDA,
00516      +                             S_WORK_CPOT01, RESULT( 1 ) )
00517                      CALL CLACPY( UPLO, N, N, ASAV, LDA, AFAC, LDA )
00518 *
00519 *                    Form the inverse and compute the residual.
00520 *
00521                     IF(MOD(N,2).EQ.0)THEN 
00522                        CALL CLACPY( 'A', N+1, N/2, ARF, N+1, ARFINV,
00523      +                               N+1 )
00524                     ELSE
00525                        CALL CLACPY( 'A', N, (N+1)/2, ARF, N, ARFINV,
00526      +                               N )
00527                     END IF
00528 *
00529                      SRNAMT = 'CPFTRI'
00530                      CALL CPFTRI( CFORM, UPLO, N, ARFINV , INFO )
00531 *
00532                      SRNAMT = 'CTFTTR'
00533                      CALL CTFTTR( CFORM, UPLO, N, ARFINV, AINV, LDA,
00534      +                            INFO )
00535 *
00536 *                    Check error code from CPFTRI.
00537 *
00538                      IF( INFO.NE.0 )
00539      +                  CALL ALAERH( 'CPO', 'CPFTRI', INFO, 0, UPLO, N,
00540      +                               N, -1, -1, -1, IMAT, NFAIL, NERRS,
00541      +                               NOUT )
00542 *
00543                      CALL CPOT03( UPLO, N, A, LDA, AINV, LDA,
00544      +                            C_WORK_CPOT03, LDA, S_WORK_CPOT03,
00545      +                            RCONDC, RESULT( 2 ) )
00546 *
00547 *                    Compute residual of the computed solution.
00548 *
00549                      CALL CLACPY( 'Full', N, NRHS, B, LDA,
00550      +                            C_WORK_CPOT02, LDA )
00551                      CALL CPOT02( UPLO, N, NRHS, A, LDA, X, LDA,
00552      +                            C_WORK_CPOT02, LDA, S_WORK_CPOT02,
00553      +                            RESULT( 3 ) )
00554 *
00555 *                    Check solution from generated exact solution.
00556 *
00557                      CALL CGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00558      +                         RESULT( 4 ) )
00559                      NT = 4
00560 *
00561 *                    Print information about the tests that did not
00562 *                    pass the threshold.
00563 *
00564                      DO 60 K = 1, NT
00565                         IF( RESULT( K ).GE.THRESH ) THEN
00566                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00567      +                        CALL ALADHD( NOUT, 'CPF' )
00568                            WRITE( NOUT, FMT = 9999 )'CPFSV ', UPLO,
00569      +                            N, IIT, K, RESULT( K )
00570                            NFAIL = NFAIL + 1
00571                         END IF
00572    60                CONTINUE
00573                      NRUN = NRUN + NT
00574   100             CONTINUE
00575   110          CONTINUE
00576   120       CONTINUE
00577   980    CONTINUE
00578   130 CONTINUE
00579 *
00580 *     Print a summary of the results.
00581 *
00582       CALL ALASVM( 'CPF', NOUT, NFAIL, NRUN, NERRS )
00583 *
00584  9999 FORMAT( 1X, A6, ', UPLO=''', A1, ''', N =', I5, ', type ', I1,
00585      +      ', test(', I1, ')=', G12.5 )
00586 *
00587       RETURN
00588 *
00589 *     End of CDRVRFP
00590 *
00591       END
 All Files Functions