![]() |
LAPACK
3.4.1
LAPACK: Linear Algebra PACKage
|
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