LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
dchkpo.f
Go to the documentation of this file.
00001 *> \brief \b DCHKPO
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 DCHKPO( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
00012 *                          THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
00013 *                          XACT, WORK, RWORK, IWORK, NOUT )
00014 * 
00015 *       .. Scalar Arguments ..
00016 *       LOGICAL            TSTERR
00017 *       INTEGER            NMAX, NN, NNB, NNS, NOUT
00018 *       DOUBLE PRECISION   THRESH
00019 *       ..
00020 *       .. Array Arguments ..
00021 *       LOGICAL            DOTYPE( * )
00022 *       INTEGER            IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
00023 *       DOUBLE PRECISION   A( * ), AFAC( * ), AINV( * ), B( * ),
00024 *      $                   RWORK( * ), WORK( * ), X( * ), XACT( * )
00025 *       ..
00026 *  
00027 *
00028 *> \par Purpose:
00029 *  =============
00030 *>
00031 *> \verbatim
00032 *>
00033 *> DCHKPO tests DPOTRF, -TRI, -TRS, -RFS, and -CON
00034 *> \endverbatim
00035 *
00036 *  Arguments:
00037 *  ==========
00038 *
00039 *> \param[in] DOTYPE
00040 *> \verbatim
00041 *>          DOTYPE is LOGICAL array, dimension (NTYPES)
00042 *>          The matrix types to be used for testing.  Matrices of type j
00043 *>          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
00044 *>          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
00045 *> \endverbatim
00046 *>
00047 *> \param[in] NN
00048 *> \verbatim
00049 *>          NN is INTEGER
00050 *>          The number of values of N contained in the vector NVAL.
00051 *> \endverbatim
00052 *>
00053 *> \param[in] NVAL
00054 *> \verbatim
00055 *>          NVAL is INTEGER array, dimension (NN)
00056 *>          The values of the matrix dimension N.
00057 *> \endverbatim
00058 *>
00059 *> \param[in] NNB
00060 *> \verbatim
00061 *>          NNB is INTEGER
00062 *>          The number of values of NB contained in the vector NBVAL.
00063 *> \endverbatim
00064 *>
00065 *> \param[in] NBVAL
00066 *> \verbatim
00067 *>          NBVAL is INTEGER array, dimension (NBVAL)
00068 *>          The values of the blocksize NB.
00069 *> \endverbatim
00070 *>
00071 *> \param[in] NNS
00072 *> \verbatim
00073 *>          NNS is INTEGER
00074 *>          The number of values of NRHS contained in the vector NSVAL.
00075 *> \endverbatim
00076 *>
00077 *> \param[in] NSVAL
00078 *> \verbatim
00079 *>          NSVAL is INTEGER array, dimension (NNS)
00080 *>          The values of the number of right hand sides NRHS.
00081 *> \endverbatim
00082 *>
00083 *> \param[in] THRESH
00084 *> \verbatim
00085 *>          THRESH is DOUBLE PRECISION
00086 *>          The threshold value for the test ratios.  A result is
00087 *>          included in the output file if RESULT >= THRESH.  To have
00088 *>          every test ratio printed, use THRESH = 0.
00089 *> \endverbatim
00090 *>
00091 *> \param[in] TSTERR
00092 *> \verbatim
00093 *>          TSTERR is LOGICAL
00094 *>          Flag that indicates whether error exits are to be tested.
00095 *> \endverbatim
00096 *>
00097 *> \param[in] NMAX
00098 *> \verbatim
00099 *>          NMAX is INTEGER
00100 *>          The maximum value permitted for N, used in dimensioning the
00101 *>          work arrays.
00102 *> \endverbatim
00103 *>
00104 *> \param[out] A
00105 *> \verbatim
00106 *>          A is DOUBLE PRECISION array, dimension (NMAX*NMAX)
00107 *> \endverbatim
00108 *>
00109 *> \param[out] AFAC
00110 *> \verbatim
00111 *>          AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)
00112 *> \endverbatim
00113 *>
00114 *> \param[out] AINV
00115 *> \verbatim
00116 *>          AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
00117 *> \endverbatim
00118 *>
00119 *> \param[out] B
00120 *> \verbatim
00121 *>          B is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
00122 *>          where NSMAX is the largest entry in NSVAL.
00123 *> \endverbatim
00124 *>
00125 *> \param[out] X
00126 *> \verbatim
00127 *>          X is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
00128 *> \endverbatim
00129 *>
00130 *> \param[out] XACT
00131 *> \verbatim
00132 *>          XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
00133 *> \endverbatim
00134 *>
00135 *> \param[out] WORK
00136 *> \verbatim
00137 *>          WORK is DOUBLE PRECISION array, dimension
00138 *>                      (NMAX*max(3,NSMAX))
00139 *> \endverbatim
00140 *>
00141 *> \param[out] RWORK
00142 *> \verbatim
00143 *>          RWORK is DOUBLE PRECISION array, dimension
00144 *>                      (max(NMAX,2*NSMAX))
00145 *> \endverbatim
00146 *>
00147 *> \param[out] IWORK
00148 *> \verbatim
00149 *>          IWORK is INTEGER array, dimension (NMAX)
00150 *> \endverbatim
00151 *>
00152 *> \param[in] NOUT
00153 *> \verbatim
00154 *>          NOUT is INTEGER
00155 *>          The unit number for output.
00156 *> \endverbatim
00157 *
00158 *  Authors:
00159 *  ========
00160 *
00161 *> \author Univ. of Tennessee 
00162 *> \author Univ. of California Berkeley 
00163 *> \author Univ. of Colorado Denver 
00164 *> \author NAG Ltd. 
00165 *
00166 *> \date November 2011
00167 *
00168 *> \ingroup double_lin
00169 *
00170 *  =====================================================================
00171       SUBROUTINE DCHKPO( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
00172      $                   THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
00173      $                   XACT, WORK, RWORK, IWORK, NOUT )
00174 *
00175 *  -- LAPACK test routine (version 3.4.0) --
00176 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00177 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00178 *     November 2011
00179 *
00180 *     .. Scalar Arguments ..
00181       LOGICAL            TSTERR
00182       INTEGER            NMAX, NN, NNB, NNS, NOUT
00183       DOUBLE PRECISION   THRESH
00184 *     ..
00185 *     .. Array Arguments ..
00186       LOGICAL            DOTYPE( * )
00187       INTEGER            IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
00188       DOUBLE PRECISION   A( * ), AFAC( * ), AINV( * ), B( * ),
00189      $                   RWORK( * ), WORK( * ), X( * ), XACT( * )
00190 *     ..
00191 *
00192 *  =====================================================================
00193 *
00194 *     .. Parameters ..
00195       DOUBLE PRECISION   ZERO
00196       PARAMETER          ( ZERO = 0.0D+0 )
00197       INTEGER            NTYPES
00198       PARAMETER          ( NTYPES = 9 )
00199       INTEGER            NTESTS
00200       PARAMETER          ( NTESTS = 8 )
00201 *     ..
00202 *     .. Local Scalars ..
00203       LOGICAL            ZEROT
00204       CHARACTER          DIST, TYPE, UPLO, XTYPE
00205       CHARACTER*3        PATH
00206       INTEGER            I, IMAT, IN, INB, INFO, IOFF, IRHS, IUPLO,
00207      $                   IZERO, K, KL, KU, LDA, MODE, N, NB, NERRS,
00208      $                   NFAIL, NIMAT, NRHS, NRUN
00209       DOUBLE PRECISION   ANORM, CNDNUM, RCOND, RCONDC
00210 *     ..
00211 *     .. Local Arrays ..
00212       CHARACTER          UPLOS( 2 )
00213       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00214       DOUBLE PRECISION   RESULT( NTESTS )
00215 *     ..
00216 *     .. External Functions ..
00217       DOUBLE PRECISION   DGET06, DLANSY
00218       EXTERNAL           DGET06, DLANSY
00219 *     ..
00220 *     .. External Subroutines ..
00221       EXTERNAL           ALAERH, ALAHD, ALASUM, DERRPO, DGET04, DLACPY,
00222      $                   DLARHS, DLATB4, DLATMS, DPOCON, DPORFS, DPOT01,
00223      $                   DPOT02, DPOT03, DPOT05, DPOTRF, DPOTRI, DPOTRS,
00224      $                   XLAENV
00225 *     ..
00226 *     .. Scalars in Common ..
00227       LOGICAL            LERR, OK
00228       CHARACTER*32       SRNAMT
00229       INTEGER            INFOT, NUNIT
00230 *     ..
00231 *     .. Common blocks ..
00232       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
00233       COMMON             / SRNAMC / SRNAMT
00234 *     ..
00235 *     .. Intrinsic Functions ..
00236       INTRINSIC          MAX
00237 *     ..
00238 *     .. Data statements ..
00239       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
00240       DATA               UPLOS / 'U', 'L' /
00241 *     ..
00242 *     .. Executable Statements ..
00243 *
00244 *     Initialize constants and the random number seed.
00245 *
00246       PATH( 1: 1 ) = 'Double precision'
00247       PATH( 2: 3 ) = 'PO'
00248       NRUN = 0
00249       NFAIL = 0
00250       NERRS = 0
00251       DO 10 I = 1, 4
00252          ISEED( I ) = ISEEDY( I )
00253    10 CONTINUE
00254 *
00255 *     Test the error exits
00256 *
00257       IF( TSTERR )
00258      $   CALL DERRPO( PATH, NOUT )
00259       INFOT = 0
00260       CALL XLAENV( 2, 2 )
00261 *
00262 *     Do for each value of N in NVAL
00263 *
00264       DO 120 IN = 1, NN
00265          N = NVAL( IN )
00266          LDA = MAX( N, 1 )
00267          XTYPE = 'N'
00268          NIMAT = NTYPES
00269          IF( N.LE.0 )
00270      $      NIMAT = 1
00271 *
00272          IZERO = 0
00273          DO 110 IMAT = 1, NIMAT
00274 *
00275 *           Do the tests only if DOTYPE( IMAT ) is true.
00276 *
00277             IF( .NOT.DOTYPE( IMAT ) )
00278      $         GO TO 110
00279 *
00280 *           Skip types 3, 4, or 5 if the matrix size is too small.
00281 *
00282             ZEROT = IMAT.GE.3 .AND. IMAT.LE.5
00283             IF( ZEROT .AND. N.LT.IMAT-2 )
00284      $         GO TO 110
00285 *
00286 *           Do first for UPLO = 'U', then for UPLO = 'L'
00287 *
00288             DO 100 IUPLO = 1, 2
00289                UPLO = UPLOS( IUPLO )
00290 *
00291 *              Set up parameters with DLATB4 and generate a test matrix
00292 *              with DLATMS.
00293 *
00294                CALL DLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00295      $                      CNDNUM, DIST )
00296 *
00297                SRNAMT = 'DLATMS'
00298                CALL DLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
00299      $                      CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
00300      $                      INFO )
00301 *
00302 *              Check error code from DLATMS.
00303 *
00304                IF( INFO.NE.0 ) THEN
00305                   CALL ALAERH( PATH, 'DLATMS', INFO, 0, UPLO, N, N, -1,
00306      $                         -1, -1, IMAT, NFAIL, NERRS, NOUT )
00307                   GO TO 100
00308                END IF
00309 *
00310 *              For types 3-5, zero one row and column of the matrix to
00311 *              test that INFO is returned correctly.
00312 *
00313                IF( ZEROT ) THEN
00314                   IF( IMAT.EQ.3 ) THEN
00315                      IZERO = 1
00316                   ELSE IF( IMAT.EQ.4 ) THEN
00317                      IZERO = N
00318                   ELSE
00319                      IZERO = N / 2 + 1
00320                   END IF
00321                   IOFF = ( IZERO-1 )*LDA
00322 *
00323 *                 Set row and column IZERO of A to 0.
00324 *
00325                   IF( IUPLO.EQ.1 ) THEN
00326                      DO 20 I = 1, IZERO - 1
00327                         A( IOFF+I ) = ZERO
00328    20                CONTINUE
00329                      IOFF = IOFF + IZERO
00330                      DO 30 I = IZERO, N
00331                         A( IOFF ) = ZERO
00332                         IOFF = IOFF + LDA
00333    30                CONTINUE
00334                   ELSE
00335                      IOFF = IZERO
00336                      DO 40 I = 1, IZERO - 1
00337                         A( IOFF ) = ZERO
00338                         IOFF = IOFF + LDA
00339    40                CONTINUE
00340                      IOFF = IOFF - IZERO
00341                      DO 50 I = IZERO, N
00342                         A( IOFF+I ) = ZERO
00343    50                CONTINUE
00344                   END IF
00345                ELSE
00346                   IZERO = 0
00347                END IF
00348 *
00349 *              Do for each value of NB in NBVAL
00350 *
00351                DO 90 INB = 1, NNB
00352                   NB = NBVAL( INB )
00353                   CALL XLAENV( 1, NB )
00354 *
00355 *                 Compute the L*L' or U'*U factorization of the matrix.
00356 *
00357                   CALL DLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
00358                   SRNAMT = 'DPOTRF'
00359                   CALL DPOTRF( UPLO, N, AFAC, LDA, INFO )
00360 *
00361 *                 Check error code from DPOTRF.
00362 *
00363                   IF( INFO.NE.IZERO ) THEN
00364                      CALL ALAERH( PATH, 'DPOTRF', INFO, IZERO, UPLO, N,
00365      $                            N, -1, -1, NB, IMAT, NFAIL, NERRS,
00366      $                            NOUT )
00367                      GO TO 90
00368                   END IF
00369 *
00370 *                 Skip the tests if INFO is not 0.
00371 *
00372                   IF( INFO.NE.0 )
00373      $               GO TO 90
00374 *
00375 *+    TEST 1
00376 *                 Reconstruct matrix from factors and compute residual.
00377 *
00378                   CALL DLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA )
00379                   CALL DPOT01( UPLO, N, A, LDA, AINV, LDA, RWORK,
00380      $                         RESULT( 1 ) )
00381 *
00382 *+    TEST 2
00383 *                 Form the inverse and compute the residual.
00384 *
00385                   CALL DLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA )
00386                   SRNAMT = 'DPOTRI'
00387                   CALL DPOTRI( UPLO, N, AINV, LDA, INFO )
00388 *
00389 *                 Check error code from DPOTRI.
00390 *
00391                   IF( INFO.NE.0 )
00392      $               CALL ALAERH( PATH, 'DPOTRI', INFO, 0, UPLO, N, N,
00393      $                            -1, -1, -1, IMAT, NFAIL, NERRS, NOUT )
00394 *
00395                   CALL DPOT03( UPLO, N, A, LDA, AINV, LDA, WORK, LDA,
00396      $                         RWORK, RCONDC, RESULT( 2 ) )
00397 *
00398 *                 Print information about the tests that did not pass
00399 *                 the threshold.
00400 *
00401                   DO 60 K = 1, 2
00402                      IF( RESULT( K ).GE.THRESH ) THEN
00403                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00404      $                     CALL ALAHD( NOUT, PATH )
00405                         WRITE( NOUT, FMT = 9999 )UPLO, N, NB, IMAT, K,
00406      $                     RESULT( K )
00407                         NFAIL = NFAIL + 1
00408                      END IF
00409    60             CONTINUE
00410                   NRUN = NRUN + 2
00411 *
00412 *                 Skip the rest of the tests unless this is the first
00413 *                 blocksize.
00414 *
00415                   IF( INB.NE.1 )
00416      $               GO TO 90
00417 *
00418                   DO 80 IRHS = 1, NNS
00419                      NRHS = NSVAL( IRHS )
00420 *
00421 *+    TEST 3
00422 *                 Solve and compute residual for A * X = B .
00423 *
00424                      SRNAMT = 'DLARHS'
00425                      CALL DLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
00426      $                            NRHS, A, LDA, XACT, LDA, B, LDA,
00427      $                            ISEED, INFO )
00428                      CALL DLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00429 *
00430                      SRNAMT = 'DPOTRS'
00431                      CALL DPOTRS( UPLO, N, NRHS, AFAC, LDA, X, LDA,
00432      $                            INFO )
00433 *
00434 *                 Check error code from DPOTRS.
00435 *
00436                      IF( INFO.NE.0 )
00437      $                  CALL ALAERH( PATH, 'DPOTRS', INFO, 0, UPLO, N,
00438      $                               N, -1, -1, NRHS, IMAT, NFAIL,
00439      $                               NERRS, NOUT )
00440 *
00441                      CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
00442                      CALL DPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
00443      $                            LDA, RWORK, RESULT( 3 ) )
00444 *
00445 *+    TEST 4
00446 *                 Check solution from generated exact solution.
00447 *
00448                      CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00449      $                            RESULT( 4 ) )
00450 *
00451 *+    TESTS 5, 6, and 7
00452 *                 Use iterative refinement to improve the solution.
00453 *
00454                      SRNAMT = 'DPORFS'
00455                      CALL DPORFS( UPLO, N, NRHS, A, LDA, AFAC, LDA, B,
00456      $                            LDA, X, LDA, RWORK, RWORK( NRHS+1 ),
00457      $                            WORK, IWORK, INFO )
00458 *
00459 *                 Check error code from DPORFS.
00460 *
00461                      IF( INFO.NE.0 )
00462      $                  CALL ALAERH( PATH, 'DPORFS', INFO, 0, UPLO, N,
00463      $                               N, -1, -1, NRHS, IMAT, NFAIL,
00464      $                               NERRS, NOUT )
00465 *
00466                      CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00467      $                            RESULT( 5 ) )
00468                      CALL DPOT05( UPLO, N, NRHS, A, LDA, B, LDA, X, LDA,
00469      $                            XACT, LDA, RWORK, RWORK( NRHS+1 ),
00470      $                            RESULT( 6 ) )
00471 *
00472 *                    Print information about the tests that did not pass
00473 *                    the threshold.
00474 *
00475                      DO 70 K = 3, 7
00476                         IF( RESULT( K ).GE.THRESH ) THEN
00477                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00478      $                        CALL ALAHD( NOUT, PATH )
00479                            WRITE( NOUT, FMT = 9998 )UPLO, N, NRHS,
00480      $                        IMAT, K, RESULT( K )
00481                            NFAIL = NFAIL + 1
00482                         END IF
00483    70                CONTINUE
00484                      NRUN = NRUN + 5
00485    80             CONTINUE
00486 *
00487 *+    TEST 8
00488 *                 Get an estimate of RCOND = 1/CNDNUM.
00489 *
00490                   ANORM = DLANSY( '1', UPLO, N, A, LDA, RWORK )
00491                   SRNAMT = 'DPOCON'
00492                   CALL DPOCON( UPLO, N, AFAC, LDA, ANORM, RCOND, WORK,
00493      $                         IWORK, INFO )
00494 *
00495 *                 Check error code from DPOCON.
00496 *
00497                   IF( INFO.NE.0 )
00498      $               CALL ALAERH( PATH, 'DPOCON', INFO, 0, UPLO, N, N,
00499      $                            -1, -1, -1, IMAT, NFAIL, NERRS, NOUT )
00500 *
00501                   RESULT( 8 ) = DGET06( RCOND, RCONDC )
00502 *
00503 *                 Print the test ratio if it is .GE. THRESH.
00504 *
00505                   IF( RESULT( 8 ).GE.THRESH ) THEN
00506                      IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00507      $                  CALL ALAHD( NOUT, PATH )
00508                      WRITE( NOUT, FMT = 9997 )UPLO, N, IMAT, 8,
00509      $                  RESULT( 8 )
00510                      NFAIL = NFAIL + 1
00511                   END IF
00512                   NRUN = NRUN + 1
00513    90          CONTINUE
00514   100       CONTINUE
00515   110    CONTINUE
00516   120 CONTINUE
00517 *
00518 *     Print a summary of the results.
00519 *
00520       CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS )
00521 *
00522  9999 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ', NB =', I4, ', type ',
00523      $      I2, ', test ', I2, ', ratio =', G12.5 )
00524  9998 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ', NRHS=', I3, ', type ',
00525      $      I2, ', test(', I2, ') =', G12.5 )
00526  9997 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ',', 10X, ' type ', I2,
00527      $      ', test(', I2, ') =', G12.5 )
00528       RETURN
00529 *
00530 *     End of DCHKPO
00531 *
00532       END
 All Files Functions