![]() |
LAPACK
3.4.1
LAPACK: Linear Algebra PACKage
|
00001 *> \brief \b DDRVGT 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 DDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, 00012 * B, X, XACT, WORK, RWORK, IWORK, NOUT ) 00013 * 00014 * .. Scalar Arguments .. 00015 * LOGICAL TSTERR 00016 * INTEGER NN, NOUT, NRHS 00017 * DOUBLE PRECISION THRESH 00018 * .. 00019 * .. Array Arguments .. 00020 * LOGICAL DOTYPE( * ) 00021 * INTEGER IWORK( * ), NVAL( * ) 00022 * DOUBLE PRECISION A( * ), AF( * ), B( * ), RWORK( * ), WORK( * ), 00023 * $ X( * ), XACT( * ) 00024 * .. 00025 * 00026 * 00027 *> \par Purpose: 00028 * ============= 00029 *> 00030 *> \verbatim 00031 *> 00032 *> DDRVGT tests DGTSV and -SVX. 00033 *> \endverbatim 00034 * 00035 * Arguments: 00036 * ========== 00037 * 00038 *> \param[in] DOTYPE 00039 *> \verbatim 00040 *> DOTYPE is LOGICAL array, dimension (NTYPES) 00041 *> The matrix types to be used for testing. Matrices of type j 00042 *> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = 00043 *> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 00044 *> \endverbatim 00045 *> 00046 *> \param[in] NN 00047 *> \verbatim 00048 *> NN is INTEGER 00049 *> The number of values of N contained in the vector NVAL. 00050 *> \endverbatim 00051 *> 00052 *> \param[in] NVAL 00053 *> \verbatim 00054 *> NVAL is INTEGER array, dimension (NN) 00055 *> The values of the matrix dimension N. 00056 *> \endverbatim 00057 *> 00058 *> \param[in] NRHS 00059 *> \verbatim 00060 *> NRHS is INTEGER 00061 *> The number of right hand sides, NRHS >= 0. 00062 *> \endverbatim 00063 *> 00064 *> \param[in] THRESH 00065 *> \verbatim 00066 *> THRESH is DOUBLE PRECISION 00067 *> The threshold value for the test ratios. A result is 00068 *> included in the output file if RESULT >= THRESH. To have 00069 *> every test ratio printed, use THRESH = 0. 00070 *> \endverbatim 00071 *> 00072 *> \param[in] TSTERR 00073 *> \verbatim 00074 *> TSTERR is LOGICAL 00075 *> Flag that indicates whether error exits are to be tested. 00076 *> \endverbatim 00077 *> 00078 *> \param[out] A 00079 *> \verbatim 00080 *> A is DOUBLE PRECISION array, dimension (NMAX*4) 00081 *> \endverbatim 00082 *> 00083 *> \param[out] AF 00084 *> \verbatim 00085 *> AF is DOUBLE PRECISION array, dimension (NMAX*4) 00086 *> \endverbatim 00087 *> 00088 *> \param[out] B 00089 *> \verbatim 00090 *> B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 00091 *> \endverbatim 00092 *> 00093 *> \param[out] X 00094 *> \verbatim 00095 *> X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 00096 *> \endverbatim 00097 *> 00098 *> \param[out] XACT 00099 *> \verbatim 00100 *> XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 00101 *> \endverbatim 00102 *> 00103 *> \param[out] WORK 00104 *> \verbatim 00105 *> WORK is DOUBLE PRECISION array, dimension 00106 *> (NMAX*max(3,NRHS)) 00107 *> \endverbatim 00108 *> 00109 *> \param[out] RWORK 00110 *> \verbatim 00111 *> RWORK is DOUBLE PRECISION array, dimension 00112 *> (max(NMAX,2*NRHS)) 00113 *> \endverbatim 00114 *> 00115 *> \param[out] IWORK 00116 *> \verbatim 00117 *> IWORK is INTEGER array, dimension (2*NMAX) 00118 *> \endverbatim 00119 *> 00120 *> \param[in] NOUT 00121 *> \verbatim 00122 *> NOUT is INTEGER 00123 *> The unit number for output. 00124 *> \endverbatim 00125 * 00126 * Authors: 00127 * ======== 00128 * 00129 *> \author Univ. of Tennessee 00130 *> \author Univ. of California Berkeley 00131 *> \author Univ. of Colorado Denver 00132 *> \author NAG Ltd. 00133 * 00134 *> \date November 2011 00135 * 00136 *> \ingroup double_lin 00137 * 00138 * ===================================================================== 00139 SUBROUTINE DDRVGT( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, 00140 $ B, X, XACT, WORK, RWORK, IWORK, NOUT ) 00141 * 00142 * -- LAPACK test routine (version 3.4.0) -- 00143 * -- LAPACK is a software package provided by Univ. of Tennessee, -- 00144 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 00145 * November 2011 00146 * 00147 * .. Scalar Arguments .. 00148 LOGICAL TSTERR 00149 INTEGER NN, NOUT, NRHS 00150 DOUBLE PRECISION THRESH 00151 * .. 00152 * .. Array Arguments .. 00153 LOGICAL DOTYPE( * ) 00154 INTEGER IWORK( * ), NVAL( * ) 00155 DOUBLE PRECISION A( * ), AF( * ), B( * ), RWORK( * ), WORK( * ), 00156 $ X( * ), XACT( * ) 00157 * .. 00158 * 00159 * ===================================================================== 00160 * 00161 * .. Parameters .. 00162 DOUBLE PRECISION ONE, ZERO 00163 PARAMETER ( ONE = 1.0D+0, ZERO = 0.0D+0 ) 00164 INTEGER NTYPES 00165 PARAMETER ( NTYPES = 12 ) 00166 INTEGER NTESTS 00167 PARAMETER ( NTESTS = 6 ) 00168 * .. 00169 * .. Local Scalars .. 00170 LOGICAL TRFCON, ZEROT 00171 CHARACTER DIST, FACT, TRANS, TYPE 00172 CHARACTER*3 PATH 00173 INTEGER I, IFACT, IMAT, IN, INFO, ITRAN, IX, IZERO, J, 00174 $ K, K1, KL, KOFF, KU, LDA, M, MODE, N, NERRS, 00175 $ NFAIL, NIMAT, NRUN, NT 00176 DOUBLE PRECISION AINVNM, ANORM, ANORMI, ANORMO, COND, RCOND, 00177 $ RCONDC, RCONDI, RCONDO 00178 * .. 00179 * .. Local Arrays .. 00180 CHARACTER TRANSS( 3 ) 00181 INTEGER ISEED( 4 ), ISEEDY( 4 ) 00182 DOUBLE PRECISION RESULT( NTESTS ), Z( 3 ) 00183 * .. 00184 * .. External Functions .. 00185 DOUBLE PRECISION DASUM, DGET06, DLANGT 00186 EXTERNAL DASUM, DGET06, DLANGT 00187 * .. 00188 * .. External Subroutines .. 00189 EXTERNAL ALADHD, ALAERH, ALASVM, DCOPY, DERRVX, DGET04, 00190 $ DGTSV, DGTSVX, DGTT01, DGTT02, DGTT05, DGTTRF, 00191 $ DGTTRS, DLACPY, DLAGTM, DLARNV, DLASET, DLATB4, 00192 $ DLATMS, DSCAL 00193 * .. 00194 * .. Intrinsic Functions .. 00195 INTRINSIC MAX 00196 * .. 00197 * .. Scalars in Common .. 00198 LOGICAL LERR, OK 00199 CHARACTER*32 SRNAMT 00200 INTEGER INFOT, NUNIT 00201 * .. 00202 * .. Common blocks .. 00203 COMMON / INFOC / INFOT, NUNIT, OK, LERR 00204 COMMON / SRNAMC / SRNAMT 00205 * .. 00206 * .. Data statements .. 00207 DATA ISEEDY / 0, 0, 0, 1 / , TRANSS / 'N', 'T', 00208 $ 'C' / 00209 * .. 00210 * .. Executable Statements .. 00211 * 00212 PATH( 1: 1 ) = 'Double precision' 00213 PATH( 2: 3 ) = 'GT' 00214 NRUN = 0 00215 NFAIL = 0 00216 NERRS = 0 00217 DO 10 I = 1, 4 00218 ISEED( I ) = ISEEDY( I ) 00219 10 CONTINUE 00220 * 00221 * Test the error exits 00222 * 00223 IF( TSTERR ) 00224 $ CALL DERRVX( PATH, NOUT ) 00225 INFOT = 0 00226 * 00227 DO 140 IN = 1, NN 00228 * 00229 * Do for each value of N in NVAL. 00230 * 00231 N = NVAL( IN ) 00232 M = MAX( N-1, 0 ) 00233 LDA = MAX( 1, N ) 00234 NIMAT = NTYPES 00235 IF( N.LE.0 ) 00236 $ NIMAT = 1 00237 * 00238 DO 130 IMAT = 1, NIMAT 00239 * 00240 * Do the tests only if DOTYPE( IMAT ) is true. 00241 * 00242 IF( .NOT.DOTYPE( IMAT ) ) 00243 $ GO TO 130 00244 * 00245 * Set up parameters with DLATB4. 00246 * 00247 CALL DLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE, 00248 $ COND, DIST ) 00249 * 00250 ZEROT = IMAT.GE.8 .AND. IMAT.LE.10 00251 IF( IMAT.LE.6 ) THEN 00252 * 00253 * Types 1-6: generate matrices of known condition number. 00254 * 00255 KOFF = MAX( 2-KU, 3-MAX( 1, N ) ) 00256 SRNAMT = 'DLATMS' 00257 CALL DLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, COND, 00258 $ ANORM, KL, KU, 'Z', AF( KOFF ), 3, WORK, 00259 $ INFO ) 00260 * 00261 * Check the error code from DLATMS. 00262 * 00263 IF( INFO.NE.0 ) THEN 00264 CALL ALAERH( PATH, 'DLATMS', INFO, 0, ' ', N, N, KL, 00265 $ KU, -1, IMAT, NFAIL, NERRS, NOUT ) 00266 GO TO 130 00267 END IF 00268 IZERO = 0 00269 * 00270 IF( N.GT.1 ) THEN 00271 CALL DCOPY( N-1, AF( 4 ), 3, A, 1 ) 00272 CALL DCOPY( N-1, AF( 3 ), 3, A( N+M+1 ), 1 ) 00273 END IF 00274 CALL DCOPY( N, AF( 2 ), 3, A( M+1 ), 1 ) 00275 ELSE 00276 * 00277 * Types 7-12: generate tridiagonal matrices with 00278 * unknown condition numbers. 00279 * 00280 IF( .NOT.ZEROT .OR. .NOT.DOTYPE( 7 ) ) THEN 00281 * 00282 * Generate a matrix with elements from [-1,1]. 00283 * 00284 CALL DLARNV( 2, ISEED, N+2*M, A ) 00285 IF( ANORM.NE.ONE ) 00286 $ CALL DSCAL( N+2*M, ANORM, A, 1 ) 00287 ELSE IF( IZERO.GT.0 ) THEN 00288 * 00289 * Reuse the last matrix by copying back the zeroed out 00290 * elements. 00291 * 00292 IF( IZERO.EQ.1 ) THEN 00293 A( N ) = Z( 2 ) 00294 IF( N.GT.1 ) 00295 $ A( 1 ) = Z( 3 ) 00296 ELSE IF( IZERO.EQ.N ) THEN 00297 A( 3*N-2 ) = Z( 1 ) 00298 A( 2*N-1 ) = Z( 2 ) 00299 ELSE 00300 A( 2*N-2+IZERO ) = Z( 1 ) 00301 A( N-1+IZERO ) = Z( 2 ) 00302 A( IZERO ) = Z( 3 ) 00303 END IF 00304 END IF 00305 * 00306 * If IMAT > 7, set one column of the matrix to 0. 00307 * 00308 IF( .NOT.ZEROT ) THEN 00309 IZERO = 0 00310 ELSE IF( IMAT.EQ.8 ) THEN 00311 IZERO = 1 00312 Z( 2 ) = A( N ) 00313 A( N ) = ZERO 00314 IF( N.GT.1 ) THEN 00315 Z( 3 ) = A( 1 ) 00316 A( 1 ) = ZERO 00317 END IF 00318 ELSE IF( IMAT.EQ.9 ) THEN 00319 IZERO = N 00320 Z( 1 ) = A( 3*N-2 ) 00321 Z( 2 ) = A( 2*N-1 ) 00322 A( 3*N-2 ) = ZERO 00323 A( 2*N-1 ) = ZERO 00324 ELSE 00325 IZERO = ( N+1 ) / 2 00326 DO 20 I = IZERO, N - 1 00327 A( 2*N-2+I ) = ZERO 00328 A( N-1+I ) = ZERO 00329 A( I ) = ZERO 00330 20 CONTINUE 00331 A( 3*N-2 ) = ZERO 00332 A( 2*N-1 ) = ZERO 00333 END IF 00334 END IF 00335 * 00336 DO 120 IFACT = 1, 2 00337 IF( IFACT.EQ.1 ) THEN 00338 FACT = 'F' 00339 ELSE 00340 FACT = 'N' 00341 END IF 00342 * 00343 * Compute the condition number for comparison with 00344 * the value returned by DGTSVX. 00345 * 00346 IF( ZEROT ) THEN 00347 IF( IFACT.EQ.1 ) 00348 $ GO TO 120 00349 RCONDO = ZERO 00350 RCONDI = ZERO 00351 * 00352 ELSE IF( IFACT.EQ.1 ) THEN 00353 CALL DCOPY( N+2*M, A, 1, AF, 1 ) 00354 * 00355 * Compute the 1-norm and infinity-norm of A. 00356 * 00357 ANORMO = DLANGT( '1', N, A, A( M+1 ), A( N+M+1 ) ) 00358 ANORMI = DLANGT( 'I', N, A, A( M+1 ), A( N+M+1 ) ) 00359 * 00360 * Factor the matrix A. 00361 * 00362 CALL DGTTRF( N, AF, AF( M+1 ), AF( N+M+1 ), 00363 $ AF( N+2*M+1 ), IWORK, INFO ) 00364 * 00365 * Use DGTTRS to solve for one column at a time of 00366 * inv(A), computing the maximum column sum as we go. 00367 * 00368 AINVNM = ZERO 00369 DO 40 I = 1, N 00370 DO 30 J = 1, N 00371 X( J ) = ZERO 00372 30 CONTINUE 00373 X( I ) = ONE 00374 CALL DGTTRS( 'No transpose', N, 1, AF, AF( M+1 ), 00375 $ AF( N+M+1 ), AF( N+2*M+1 ), IWORK, X, 00376 $ LDA, INFO ) 00377 AINVNM = MAX( AINVNM, DASUM( N, X, 1 ) ) 00378 40 CONTINUE 00379 * 00380 * Compute the 1-norm condition number of A. 00381 * 00382 IF( ANORMO.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 00383 RCONDO = ONE 00384 ELSE 00385 RCONDO = ( ONE / ANORMO ) / AINVNM 00386 END IF 00387 * 00388 * Use DGTTRS to solve for one column at a time of 00389 * inv(A'), computing the maximum column sum as we go. 00390 * 00391 AINVNM = ZERO 00392 DO 60 I = 1, N 00393 DO 50 J = 1, N 00394 X( J ) = ZERO 00395 50 CONTINUE 00396 X( I ) = ONE 00397 CALL DGTTRS( 'Transpose', N, 1, AF, AF( M+1 ), 00398 $ AF( N+M+1 ), AF( N+2*M+1 ), IWORK, X, 00399 $ LDA, INFO ) 00400 AINVNM = MAX( AINVNM, DASUM( N, X, 1 ) ) 00401 60 CONTINUE 00402 * 00403 * Compute the infinity-norm condition number of A. 00404 * 00405 IF( ANORMI.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN 00406 RCONDI = ONE 00407 ELSE 00408 RCONDI = ( ONE / ANORMI ) / AINVNM 00409 END IF 00410 END IF 00411 * 00412 DO 110 ITRAN = 1, 3 00413 TRANS = TRANSS( ITRAN ) 00414 IF( ITRAN.EQ.1 ) THEN 00415 RCONDC = RCONDO 00416 ELSE 00417 RCONDC = RCONDI 00418 END IF 00419 * 00420 * Generate NRHS random solution vectors. 00421 * 00422 IX = 1 00423 DO 70 J = 1, NRHS 00424 CALL DLARNV( 2, ISEED, N, XACT( IX ) ) 00425 IX = IX + LDA 00426 70 CONTINUE 00427 * 00428 * Set the right hand side. 00429 * 00430 CALL DLAGTM( TRANS, N, NRHS, ONE, A, A( M+1 ), 00431 $ A( N+M+1 ), XACT, LDA, ZERO, B, LDA ) 00432 * 00433 IF( IFACT.EQ.2 .AND. ITRAN.EQ.1 ) THEN 00434 * 00435 * --- Test DGTSV --- 00436 * 00437 * Solve the system using Gaussian elimination with 00438 * partial pivoting. 00439 * 00440 CALL DCOPY( N+2*M, A, 1, AF, 1 ) 00441 CALL DLACPY( 'Full', N, NRHS, B, LDA, X, LDA ) 00442 * 00443 SRNAMT = 'DGTSV ' 00444 CALL DGTSV( N, NRHS, AF, AF( M+1 ), AF( N+M+1 ), X, 00445 $ LDA, INFO ) 00446 * 00447 * Check error code from DGTSV . 00448 * 00449 IF( INFO.NE.IZERO ) 00450 $ CALL ALAERH( PATH, 'DGTSV ', INFO, IZERO, ' ', 00451 $ N, N, 1, 1, NRHS, IMAT, NFAIL, 00452 $ NERRS, NOUT ) 00453 NT = 1 00454 IF( IZERO.EQ.0 ) THEN 00455 * 00456 * Check residual of computed solution. 00457 * 00458 CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK, 00459 $ LDA ) 00460 CALL DGTT02( TRANS, N, NRHS, A, A( M+1 ), 00461 $ A( N+M+1 ), X, LDA, WORK, LDA, 00462 $ RESULT( 2 ) ) 00463 * 00464 * Check solution from generated exact solution. 00465 * 00466 CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC, 00467 $ RESULT( 3 ) ) 00468 NT = 3 00469 END IF 00470 * 00471 * Print information about the tests that did not pass 00472 * the threshold. 00473 * 00474 DO 80 K = 2, NT 00475 IF( RESULT( K ).GE.THRESH ) THEN 00476 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00477 $ CALL ALADHD( NOUT, PATH ) 00478 WRITE( NOUT, FMT = 9999 )'DGTSV ', N, IMAT, 00479 $ K, RESULT( K ) 00480 NFAIL = NFAIL + 1 00481 END IF 00482 80 CONTINUE 00483 NRUN = NRUN + NT - 1 00484 END IF 00485 * 00486 * --- Test DGTSVX --- 00487 * 00488 IF( IFACT.GT.1 ) THEN 00489 * 00490 * Initialize AF to zero. 00491 * 00492 DO 90 I = 1, 3*N - 2 00493 AF( I ) = ZERO 00494 90 CONTINUE 00495 END IF 00496 CALL DLASET( 'Full', N, NRHS, ZERO, ZERO, X, LDA ) 00497 * 00498 * Solve the system and compute the condition number and 00499 * error bounds using DGTSVX. 00500 * 00501 SRNAMT = 'DGTSVX' 00502 CALL DGTSVX( FACT, TRANS, N, NRHS, A, A( M+1 ), 00503 $ A( N+M+1 ), AF, AF( M+1 ), AF( N+M+1 ), 00504 $ AF( N+2*M+1 ), IWORK, B, LDA, X, LDA, 00505 $ RCOND, RWORK, RWORK( NRHS+1 ), WORK, 00506 $ IWORK( N+1 ), INFO ) 00507 * 00508 * Check the error code from DGTSVX. 00509 * 00510 IF( INFO.NE.IZERO ) 00511 $ CALL ALAERH( PATH, 'DGTSVX', INFO, IZERO, 00512 $ FACT // TRANS, N, N, 1, 1, NRHS, IMAT, 00513 $ NFAIL, NERRS, NOUT ) 00514 * 00515 IF( IFACT.GE.2 ) THEN 00516 * 00517 * Reconstruct matrix from factors and compute 00518 * residual. 00519 * 00520 CALL DGTT01( N, A, A( M+1 ), A( N+M+1 ), AF, 00521 $ AF( M+1 ), AF( N+M+1 ), AF( N+2*M+1 ), 00522 $ IWORK, WORK, LDA, RWORK, RESULT( 1 ) ) 00523 K1 = 1 00524 ELSE 00525 K1 = 2 00526 END IF 00527 * 00528 IF( INFO.EQ.0 ) THEN 00529 TRFCON = .FALSE. 00530 * 00531 * Check residual of computed solution. 00532 * 00533 CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA ) 00534 CALL DGTT02( TRANS, N, NRHS, A, A( M+1 ), 00535 $ A( N+M+1 ), X, LDA, WORK, LDA, 00536 $ RESULT( 2 ) ) 00537 * 00538 * Check solution from generated exact solution. 00539 * 00540 CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC, 00541 $ RESULT( 3 ) ) 00542 * 00543 * Check the error bounds from iterative refinement. 00544 * 00545 CALL DGTT05( TRANS, N, NRHS, A, A( M+1 ), 00546 $ A( N+M+1 ), B, LDA, X, LDA, XACT, LDA, 00547 $ RWORK, RWORK( NRHS+1 ), RESULT( 4 ) ) 00548 NT = 5 00549 END IF 00550 * 00551 * Print information about the tests that did not pass 00552 * the threshold. 00553 * 00554 DO 100 K = K1, NT 00555 IF( RESULT( K ).GE.THRESH ) THEN 00556 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00557 $ CALL ALADHD( NOUT, PATH ) 00558 WRITE( NOUT, FMT = 9998 )'DGTSVX', FACT, TRANS, 00559 $ N, IMAT, K, RESULT( K ) 00560 NFAIL = NFAIL + 1 00561 END IF 00562 100 CONTINUE 00563 * 00564 * Check the reciprocal of the condition number. 00565 * 00566 RESULT( 6 ) = DGET06( RCOND, RCONDC ) 00567 IF( RESULT( 6 ).GE.THRESH ) THEN 00568 IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 ) 00569 $ CALL ALADHD( NOUT, PATH ) 00570 WRITE( NOUT, FMT = 9998 )'DGTSVX', FACT, TRANS, N, 00571 $ IMAT, K, RESULT( K ) 00572 NFAIL = NFAIL + 1 00573 END IF 00574 NRUN = NRUN + NT - K1 + 2 00575 * 00576 110 CONTINUE 00577 120 CONTINUE 00578 130 CONTINUE 00579 140 CONTINUE 00580 * 00581 * Print a summary of the results. 00582 * 00583 CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS ) 00584 * 00585 9999 FORMAT( 1X, A, ', N =', I5, ', type ', I2, ', test ', I2, 00586 $ ', ratio = ', G12.5 ) 00587 9998 FORMAT( 1X, A, ', FACT=''', A1, ''', TRANS=''', A1, ''', N =', 00588 $ I5, ', type ', I2, ', test ', I2, ', ratio = ', G12.5 ) 00589 RETURN 00590 * 00591 * End of DDRVGT 00592 * 00593 END