LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
zdrvrfp.f
Go to the documentation of this file.
00001 *> \brief \b ZDRVRFP
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 ZDRVRFP( NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL,
00012 *      +              THRESH, A, ASAV, AFAC, AINV, B,
00013 *      +              BSAV, XACT, X, ARF, ARFINV,
00014 *      +              Z_WORK_ZLATMS, Z_WORK_ZPOT02,
00015 *      +              Z_WORK_ZPOT03, D_WORK_ZLATMS, D_WORK_ZLANHE,
00016 *      +              D_WORK_ZPOT01, D_WORK_ZPOT02, D_WORK_ZPOT03 )
00017 * 
00018 *       .. Scalar Arguments ..
00019 *       INTEGER            NN, NNS, NNT, NOUT
00020 *       DOUBLE PRECISION   THRESH
00021 *       ..
00022 *       .. Array Arguments ..
00023 *       INTEGER            NVAL( NN ), NSVAL( NNS ), NTVAL( NNT )
00024 *       COMPLEX*16         A( * )
00025 *       COMPLEX*16         AINV( * )
00026 *       COMPLEX*16         ASAV( * )
00027 *       COMPLEX*16         B( * )
00028 *       COMPLEX*16         BSAV( * )
00029 *       COMPLEX*16         AFAC( * )
00030 *       COMPLEX*16         ARF( * )
00031 *       COMPLEX*16         ARFINV( * )
00032 *       COMPLEX*16         XACT( * )
00033 *       COMPLEX*16         X( * )
00034 *       COMPLEX*16         Z_WORK_ZLATMS( * )
00035 *       COMPLEX*16         Z_WORK_ZPOT02( * )
00036 *       COMPLEX*16         Z_WORK_ZPOT03( * )
00037 *       DOUBLE PRECISION   D_WORK_ZLATMS( * )
00038 *       DOUBLE PRECISION   D_WORK_ZLANHE( * )
00039 *       DOUBLE PRECISION   D_WORK_ZPOT01( * )
00040 *       DOUBLE PRECISION   D_WORK_ZPOT02( * )
00041 *       DOUBLE PRECISION   D_WORK_ZPOT03( * )
00042 *       ..
00043 *  
00044 *
00045 *> \par Purpose:
00046 *  =============
00047 *>
00048 *> \verbatim
00049 *>
00050 *> ZDRVRFP tests the LAPACK RFP routines:
00051 *>     ZPFTRF, ZPFTRS, and ZPFTRI.
00052 *>
00053 *> This testing routine follow the same tests as ZDRVPO (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 ZTRTTF and
00058 *> ZTFTTR.
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 ZPFTRF, 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 ZPFTRF 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 DOUBLE PRECISION
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*16 array, dimension (NMAX*NMAX)
00140 *> \endverbatim
00141 *>
00142 *> \param[out] ASAV
00143 *> \verbatim
00144 *>          ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
00145 *> \endverbatim
00146 *>
00147 *> \param[out] AFAC
00148 *> \verbatim
00149 *>          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
00150 *> \endverbatim
00151 *>
00152 *> \param[out] AINV
00153 *> \verbatim
00154 *>          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
00155 *> \endverbatim
00156 *>
00157 *> \param[out] B
00158 *> \verbatim
00159 *>          B is COMPLEX*16 array, dimension (NMAX*MAXRHS)
00160 *> \endverbatim
00161 *>
00162 *> \param[out] BSAV
00163 *> \verbatim
00164 *>          BSAV is COMPLEX*16 array, dimension (NMAX*MAXRHS)
00165 *> \endverbatim
00166 *>
00167 *> \param[out] XACT
00168 *> \verbatim
00169 *>          XACT is COMPLEX*16 array, dimension (NMAX*MAXRHS)
00170 *> \endverbatim
00171 *>
00172 *> \param[out] X
00173 *> \verbatim
00174 *>          X is COMPLEX*16 array, dimension (NMAX*MAXRHS)
00175 *> \endverbatim
00176 *>
00177 *> \param[out] ARF
00178 *> \verbatim
00179 *>          ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
00180 *> \endverbatim
00181 *>
00182 *> \param[out] ARFINV
00183 *> \verbatim
00184 *>          ARFINV is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
00185 *> \endverbatim
00186 *>
00187 *> \param[out] Z_WORK_ZLATMS
00188 *> \verbatim
00189 *>          Z_WORK_ZLATMS is COMPLEX*16 array, dimension ( 3*NMAX )
00190 *> \endverbatim
00191 *>
00192 *> \param[out] Z_WORK_ZPOT02
00193 *> \verbatim
00194 *>          Z_WORK_ZPOT02 is COMPLEX*16 array, dimension ( NMAX*MAXRHS )
00195 *> \endverbatim
00196 *>
00197 *> \param[out] Z_WORK_ZPOT03
00198 *> \verbatim
00199 *>          Z_WORK_ZPOT03 is COMPLEX*16 array, dimension ( NMAX*NMAX )
00200 *> \endverbatim
00201 *>
00202 *> \param[out] D_WORK_ZLATMS
00203 *> \verbatim
00204 *>          D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX )
00205 *> \endverbatim
00206 *>
00207 *> \param[out] D_WORK_ZLANHE
00208 *> \verbatim
00209 *>          D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX )
00210 *> \endverbatim
00211 *>
00212 *> \param[out] D_WORK_ZPOT01
00213 *> \verbatim
00214 *>          D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX )
00215 *> \endverbatim
00216 *>
00217 *> \param[out] D_WORK_ZPOT02
00218 *> \verbatim
00219 *>          D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX )
00220 *> \endverbatim
00221 *>
00222 *> \param[out] D_WORK_ZPOT03
00223 *> \verbatim
00224 *>          D_WORK_ZPOT03 is DOUBLE PRECISION 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 complex16_lin
00238 *
00239 *  =====================================================================
00240       SUBROUTINE ZDRVRFP( NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL,
00241      +              THRESH, A, ASAV, AFAC, AINV, B,
00242      +              BSAV, XACT, X, ARF, ARFINV,
00243      +              Z_WORK_ZLATMS, Z_WORK_ZPOT02,
00244      +              Z_WORK_ZPOT03, D_WORK_ZLATMS, D_WORK_ZLANHE,
00245      +              D_WORK_ZPOT01, D_WORK_ZPOT02, D_WORK_ZPOT03 )
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       DOUBLE PRECISION   THRESH
00255 *     ..
00256 *     .. Array Arguments ..
00257       INTEGER            NVAL( NN ), NSVAL( NNS ), NTVAL( NNT )
00258       COMPLEX*16         A( * )
00259       COMPLEX*16         AINV( * )
00260       COMPLEX*16         ASAV( * )
00261       COMPLEX*16         B( * )
00262       COMPLEX*16         BSAV( * )
00263       COMPLEX*16         AFAC( * )
00264       COMPLEX*16         ARF( * )
00265       COMPLEX*16         ARFINV( * )
00266       COMPLEX*16         XACT( * )
00267       COMPLEX*16         X( * )
00268       COMPLEX*16         Z_WORK_ZLATMS( * )
00269       COMPLEX*16         Z_WORK_ZPOT02( * )
00270       COMPLEX*16         Z_WORK_ZPOT03( * )
00271       DOUBLE PRECISION   D_WORK_ZLATMS( * )
00272       DOUBLE PRECISION   D_WORK_ZLANHE( * )
00273       DOUBLE PRECISION   D_WORK_ZPOT01( * )
00274       DOUBLE PRECISION   D_WORK_ZPOT02( * )
00275       DOUBLE PRECISION   D_WORK_ZPOT03( * )
00276 *     ..
00277 *
00278 *  =====================================================================
00279 *
00280 *     .. Parameters ..
00281       DOUBLE PRECISION   ONE, ZERO
00282       PARAMETER          ( ONE = 1.0D+0, ZERO = 0.0D+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       DOUBLE PRECISION   ANORM, AINVNM, CNDNUM, RCONDC
00294 *     ..
00295 *     .. Local Arrays ..
00296       CHARACTER          UPLOS( 2 ), FORMS( 2 )
00297       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00298       DOUBLE PRECISION   RESULT( NTESTS )
00299 *     ..
00300 *     .. External Functions ..
00301       DOUBLE PRECISION   ZLANHE
00302       EXTERNAL           ZLANHE
00303 *     ..
00304 *     .. External Subroutines ..
00305       EXTERNAL           ALADHD, ALAERH, ALASVM, ZGET04, ZTFTTR, ZLACPY,
00306      +                   ZLAIPD, ZLARHS, ZLATB4, ZLATMS, ZPFTRI, ZPFTRF,
00307      +                   ZPFTRS, ZPOT01, ZPOT02, ZPOT03, ZPOTRI, ZPOTRF,
00308      +                   ZTRTTF
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 ZLATB4 and generate a test
00366 *                    matrix with ZLATMS.
00367 *
00368                      CALL ZLATB4( 'ZPO', IMAT, N, N, CTYPE, KL, KU,
00369      +                            ANORM, MODE, CNDNUM, DIST )
00370 *
00371                      SRNAMT = 'ZLATMS'
00372                      CALL ZLATMS( N, N, DIST, ISEED, CTYPE,
00373      +                            D_WORK_ZLATMS,
00374      +                            MODE, CNDNUM, ANORM, KL, KU, UPLO, A,
00375      +                            LDA, Z_WORK_ZLATMS, INFO )
00376 *
00377 *                    Check error code from ZLATMS.
00378 *
00379                      IF( INFO.NE.0 ) THEN
00380                         CALL ALAERH( 'ZPF', 'ZLATMS', 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 ZLAIPD( N, A, LDA+1, 0 )
00429 *
00430 *                    Save a copy of the matrix A in ASAV.
00431 *
00432                      CALL ZLACPY( 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 = ZLANHE( '1', UPLO, N, A, LDA,
00443      +                         D_WORK_ZLANHE )
00444 *
00445 *                       Factor the matrix A.
00446 *
00447                         CALL ZPOTRF( UPLO, N, A, LDA, INFO )
00448 *
00449 *                       Form the inverse of A.
00450 *
00451                         CALL ZPOTRI( UPLO, N, A, LDA, INFO )
00452 *
00453 *                       Compute the 1-norm condition number of A.
00454 *
00455                         AINVNM = ZLANHE( '1', UPLO, N, A, LDA,
00456      +                           D_WORK_ZLANHE )
00457                         RCONDC = ( ONE / ANORM ) / AINVNM
00458 *
00459 *                       Restore the matrix A.
00460 *
00461                         CALL ZLACPY( 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 = 'ZLARHS'
00468                      CALL ZLARHS( 'ZPO', 'N', UPLO, ' ', N, N, KL, KU,
00469      +                            NRHS, A, LDA, XACT, LDA, B, LDA,
00470      +                            ISEED, INFO )
00471                      CALL ZLACPY( '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 ZLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
00477                      CALL ZLACPY( 'Full', N, NRHS, B, LDB, X, LDB )
00478 *
00479                      SRNAMT = 'ZTRTTF'
00480                      CALL ZTRTTF( CFORM, UPLO, N, AFAC, LDA, ARF, INFO )
00481                      SRNAMT = 'ZPFTRF'
00482                      CALL ZPFTRF( CFORM, UPLO, N, ARF, INFO )
00483 *
00484 *                    Check error code from ZPFTRF.
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( 'ZPF', 'ZPFSV ', 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 = 'ZPFTRS'
00505                      CALL ZPFTRS( CFORM, UPLO, N, NRHS, ARF, X, LDB,
00506      +                            INFO )
00507 *
00508                      SRNAMT = 'ZTFTTR'
00509                      CALL ZTFTTR( CFORM, UPLO, N, ARF, AFAC, LDA, INFO )
00510 *
00511 *                    Reconstruct matrix from factors and compute
00512 *                    residual.
00513 *
00514                      CALL ZLACPY( UPLO, N, N, AFAC, LDA, ASAV, LDA )
00515                      CALL ZPOT01( UPLO, N, A, LDA, AFAC, LDA,
00516      +                             D_WORK_ZPOT01, RESULT( 1 ) )
00517                      CALL ZLACPY( 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 ZLACPY( 'A', N+1, N/2, ARF, N+1, ARFINV,
00523      +                               N+1 )
00524                     ELSE
00525                        CALL ZLACPY( 'A', N, (N+1)/2, ARF, N, ARFINV,
00526      +                               N )
00527                     END IF
00528 *
00529                      SRNAMT = 'ZPFTRI'
00530                      CALL ZPFTRI( CFORM, UPLO, N, ARFINV , INFO )
00531 *
00532                      SRNAMT = 'ZTFTTR'
00533                      CALL ZTFTTR( CFORM, UPLO, N, ARFINV, AINV, LDA,
00534      +                            INFO )
00535 *
00536 *                    Check error code from ZPFTRI.
00537 *
00538                      IF( INFO.NE.0 )
00539      +                  CALL ALAERH( 'ZPO', 'ZPFTRI', INFO, 0, UPLO, N,
00540      +                               N, -1, -1, -1, IMAT, NFAIL, NERRS,
00541      +                               NOUT )
00542 *
00543                      CALL ZPOT03( UPLO, N, A, LDA, AINV, LDA,
00544      +                            Z_WORK_ZPOT03, LDA, D_WORK_ZPOT03,
00545      +                            RCONDC, RESULT( 2 ) )
00546 *
00547 *                    Compute residual of the computed solution.
00548 *
00549                      CALL ZLACPY( 'Full', N, NRHS, B, LDA,
00550      +                            Z_WORK_ZPOT02, LDA )
00551                      CALL ZPOT02( UPLO, N, NRHS, A, LDA, X, LDA,
00552      +                            Z_WORK_ZPOT02, LDA, D_WORK_ZPOT02,
00553      +                            RESULT( 3 ) )
00554 *
00555 *                    Check solution from generated exact solution.
00556 *
00557                      CALL ZGET04( 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, 'ZPF' )
00568                            WRITE( NOUT, FMT = 9999 )'ZPFSV ', 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( 'ZPF', 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 ZDRVRFP
00590 *
00591       END
 All Files Functions