LAPACK 3.3.1 Linear Algebra PACKage

# schktr.f

Go to the documentation of this file.
```00001       SUBROUTINE SCHKTR( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
00002      \$                   THRESH, TSTERR, NMAX, A, AINV, B, X, XACT,
00003      \$                   WORK, RWORK, IWORK, NOUT )
00004 *
00005 *  -- LAPACK test routine (version 3.1) --
00006 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
00007 *     November 2006
00008 *
00009 *     .. Scalar Arguments ..
00010       LOGICAL            TSTERR
00011       INTEGER            NMAX, NN, NNB, NNS, NOUT
00012       REAL               THRESH
00013 *     ..
00014 *     .. Array Arguments ..
00015       LOGICAL            DOTYPE( * )
00016       INTEGER            IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
00017       REAL               A( * ), AINV( * ), B( * ), RWORK( * ),
00018      \$                   WORK( * ), X( * ), XACT( * )
00019 *     ..
00020 *
00021 *  Purpose
00022 *  =======
00023 *
00024 *  SCHKTR tests STRTRI, -TRS, -RFS, and -CON, and SLATRS
00025 *
00026 *  Arguments
00027 *  =========
00028 *
00029 *  DOTYPE  (input) LOGICAL array, dimension (NTYPES)
00030 *          The matrix types to be used for testing.  Matrices of type j
00031 *          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
00032 *          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
00033 *
00034 *  NN      (input) INTEGER
00035 *          The number of values of N contained in the vector NVAL.
00036 *
00037 *  NVAL    (input) INTEGER array, dimension (NN)
00038 *          The values of the matrix column dimension N.
00039 *
00040 *  NNB     (input) INTEGER
00041 *          The number of values of NB contained in the vector NBVAL.
00042 *
00043 *  NBVAL   (input) INTEGER array, dimension (NNB)
00044 *          The values of the blocksize NB.
00045 *
00046 *  NNS     (input) INTEGER
00047 *          The number of values of NRHS contained in the vector NSVAL.
00048 *
00049 *  NSVAL   (input) INTEGER array, dimension (NNS)
00050 *          The values of the number of right hand sides NRHS.
00051 *
00052 *  THRESH  (input) REAL
00053 *          The threshold value for the test ratios.  A result is
00054 *          included in the output file if RESULT >= THRESH.  To have
00055 *          every test ratio printed, use THRESH = 0.
00056 *
00057 *  TSTERR  (input) LOGICAL
00058 *          Flag that indicates whether error exits are to be tested.
00059 *
00060 *  NMAX    (input) INTEGER
00061 *          The leading dimension of the work arrays.
00062 *          NMAX >= the maximum value of N in NVAL.
00063 *
00064 *  A       (workspace) REAL array, dimension (NMAX*NMAX)
00065 *
00066 *  AINV    (workspace) REAL array, dimension (NMAX*NMAX)
00067 *
00068 *  B       (workspace) REAL array, dimension (NMAX*NSMAX)
00069 *          where NSMAX is the largest entry in NSVAL.
00070 *
00071 *  X       (workspace) REAL array, dimension (NMAX*NSMAX)
00072 *
00073 *  XACT    (workspace) REAL array, dimension (NMAX*NSMAX)
00074 *
00075 *  WORK    (workspace) REAL array, dimension
00076 *                      (NMAX*max(3,NSMAX))
00077 *
00078 *  RWORK   (workspace) REAL array, dimension
00079 *                      (max(NMAX,2*NSMAX))
00080 *
00081 *  IWORK   (workspace) INTEGER array, dimension (NMAX)
00082 *
00083 *  NOUT    (input) INTEGER
00084 *          The unit number for output.
00085 *
00086 *  =====================================================================
00087 *
00088 *     .. Parameters ..
00089       INTEGER            NTYPE1, NTYPES
00090       PARAMETER          ( NTYPE1 = 10, NTYPES = 18 )
00091       INTEGER            NTESTS
00092       PARAMETER          ( NTESTS = 9 )
00093       INTEGER            NTRAN
00094       PARAMETER          ( NTRAN = 3 )
00095       REAL               ONE, ZERO
00096       PARAMETER          ( ONE = 1.0E0, ZERO = 0.0E0 )
00097 *     ..
00098 *     .. Local Scalars ..
00099       CHARACTER          DIAG, NORM, TRANS, UPLO, XTYPE
00100       CHARACTER*3        PATH
00101       INTEGER            I, IDIAG, IMAT, IN, INB, INFO, IRHS, ITRAN,
00102      \$                   IUPLO, K, LDA, N, NB, NERRS, NFAIL, NRHS, NRUN
00103       REAL               AINVNM, ANORM, DUMMY, RCOND, RCONDC, RCONDI,
00104      \$                   RCONDO, SCALE
00105 *     ..
00106 *     .. Local Arrays ..
00107       CHARACTER          TRANSS( NTRAN ), UPLOS( 2 )
00108       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00109       REAL               RESULT( NTESTS )
00110 *     ..
00111 *     .. External Functions ..
00112       LOGICAL            LSAME
00113       REAL               SLANTR
00114       EXTERNAL           LSAME, SLANTR
00115 *     ..
00116 *     .. External Subroutines ..
00117       EXTERNAL           ALAERH, ALAHD, ALASUM, SCOPY, SERRTR, SGET04,
00118      \$                   SLACPY, SLARHS, SLATRS, SLATTR, STRCON, STRRFS,
00119      \$                   STRT01, STRT02, STRT03, STRT05, STRT06, STRTRI,
00120      \$                   STRTRS, XLAENV
00121 *     ..
00122 *     .. Scalars in Common ..
00123       LOGICAL            LERR, OK
00124       CHARACTER*32       SRNAMT
00125       INTEGER            INFOT, IOUNIT
00126 *     ..
00127 *     .. Common blocks ..
00128       COMMON             / INFOC / INFOT, IOUNIT, OK, LERR
00129       COMMON             / SRNAMC / SRNAMT
00130 *     ..
00131 *     .. Intrinsic Functions ..
00132       INTRINSIC          MAX
00133 *     ..
00134 *     .. Data statements ..
00135       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
00136       DATA               UPLOS / 'U', 'L' / , TRANSS / 'N', 'T', 'C' /
00137 *     ..
00138 *     .. Executable Statements ..
00139 *
00140 *     Initialize constants and the random number seed.
00141 *
00142       PATH( 1: 1 ) = 'Single precision'
00143       PATH( 2: 3 ) = 'TR'
00144       NRUN = 0
00145       NFAIL = 0
00146       NERRS = 0
00147       DO 10 I = 1, 4
00148          ISEED( I ) = ISEEDY( I )
00149    10 CONTINUE
00150 *
00151 *     Test the error exits
00152 *
00153       IF( TSTERR )
00154      \$   CALL SERRTR( PATH, NOUT )
00155       INFOT = 0
00156       CALL XLAENV( 2, 2 )
00157 *
00158       DO 120 IN = 1, NN
00159 *
00160 *        Do for each value of N in NVAL
00161 *
00162          N = NVAL( IN )
00163          LDA = MAX( 1, N )
00164          XTYPE = 'N'
00165 *
00166          DO 80 IMAT = 1, NTYPE1
00167 *
00168 *           Do the tests only if DOTYPE( IMAT ) is true.
00169 *
00170             IF( .NOT.DOTYPE( IMAT ) )
00171      \$         GO TO 80
00172 *
00173             DO 70 IUPLO = 1, 2
00174 *
00175 *              Do first for UPLO = 'U', then for UPLO = 'L'
00176 *
00177                UPLO = UPLOS( IUPLO )
00178 *
00179 *              Call SLATTR to generate a triangular test matrix.
00180 *
00181                SRNAMT = 'SLATTR'
00182                CALL SLATTR( IMAT, UPLO, 'No transpose', DIAG, ISEED, N,
00183      \$                      A, LDA, X, WORK, INFO )
00184 *
00185 *              Set IDIAG = 1 for non-unit matrices, 2 for unit.
00186 *
00187                IF( LSAME( DIAG, 'N' ) ) THEN
00188                   IDIAG = 1
00189                ELSE
00190                   IDIAG = 2
00191                END IF
00192 *
00193                DO 60 INB = 1, NNB
00194 *
00195 *                 Do for each blocksize in NBVAL
00196 *
00197                   NB = NBVAL( INB )
00198                   CALL XLAENV( 1, NB )
00199 *
00200 *+    TEST 1
00201 *                 Form the inverse of A.
00202 *
00203                   CALL SLACPY( UPLO, N, N, A, LDA, AINV, LDA )
00204                   SRNAMT = 'STRTRI'
00205                   CALL STRTRI( UPLO, DIAG, N, AINV, LDA, INFO )
00206 *
00207 *                 Check error code from STRTRI.
00208 *
00209                   IF( INFO.NE.0 )
00210      \$               CALL ALAERH( PATH, 'STRTRI', INFO, 0, UPLO // DIAG,
00211      \$                            N, N, -1, -1, NB, IMAT, NFAIL, NERRS,
00212      \$                            NOUT )
00213 *
00214 *                 Compute the infinity-norm condition number of A.
00215 *
00216                   ANORM = SLANTR( 'I', UPLO, DIAG, N, N, A, LDA, RWORK )
00217                   AINVNM = SLANTR( 'I', UPLO, DIAG, N, N, AINV, LDA,
00218      \$                     RWORK )
00219                   IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00220                      RCONDI = ONE
00221                   ELSE
00222                      RCONDI = ( ONE / ANORM ) / AINVNM
00223                   END IF
00224 *
00225 *                 Compute the residual for the triangular matrix times
00226 *                 its inverse.  Also compute the 1-norm condition number
00227 *                 of A.
00228 *
00229                   CALL STRT01( UPLO, DIAG, N, A, LDA, AINV, LDA, RCONDO,
00230      \$                         RWORK, RESULT( 1 ) )
00231 *
00232 *                 Print the test ratio if it is .GE. THRESH.
00233 *
00234                   IF( RESULT( 1 ).GE.THRESH ) THEN
00235                      IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00236      \$                  CALL ALAHD( NOUT, PATH )
00237                      WRITE( NOUT, FMT = 9999 )UPLO, DIAG, N, NB, IMAT,
00238      \$                  1, RESULT( 1 )
00239                      NFAIL = NFAIL + 1
00240                   END IF
00241                   NRUN = NRUN + 1
00242 *
00243 *                 Skip remaining tests if not the first block size.
00244 *
00245                   IF( INB.NE.1 )
00246      \$               GO TO 60
00247 *
00248                   DO 40 IRHS = 1, NNS
00249                      NRHS = NSVAL( IRHS )
00250                      XTYPE = 'N'
00251 *
00252                      DO 30 ITRAN = 1, NTRAN
00253 *
00254 *                    Do for op(A) = A, A**T, or A**H.
00255 *
00256                         TRANS = TRANSS( ITRAN )
00257                         IF( ITRAN.EQ.1 ) THEN
00258                            NORM = 'O'
00259                            RCONDC = RCONDO
00260                         ELSE
00261                            NORM = 'I'
00262                            RCONDC = RCONDI
00263                         END IF
00264 *
00265 *+    TEST 2
00266 *                       Solve and compute residual for op(A)*x = b.
00267 *
00268                         SRNAMT = 'SLARHS'
00269                         CALL SLARHS( PATH, XTYPE, UPLO, TRANS, N, N, 0,
00270      \$                               IDIAG, NRHS, A, LDA, XACT, LDA, B,
00271      \$                               LDA, ISEED, INFO )
00272                         XTYPE = 'C'
00273                         CALL SLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00274 *
00275                         SRNAMT = 'STRTRS'
00276                         CALL STRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA,
00277      \$                               X, LDA, INFO )
00278 *
00279 *                       Check error code from STRTRS.
00280 *
00281                         IF( INFO.NE.0 )
00282      \$                     CALL ALAERH( PATH, 'STRTRS', INFO, 0,
00283      \$                                  UPLO // TRANS // DIAG, N, N, -1,
00284      \$                                  -1, NRHS, IMAT, NFAIL, NERRS,
00285      \$                                  NOUT )
00286 *
00287 *                       This line is needed on a Sun SPARCstation.
00288 *
00289                         IF( N.GT.0 )
00290      \$                     DUMMY = A( 1 )
00291 *
00292                         CALL STRT02( UPLO, TRANS, DIAG, N, NRHS, A, LDA,
00293      \$                               X, LDA, B, LDA, WORK, RESULT( 2 ) )
00294 *
00295 *+    TEST 3
00296 *                       Check solution from generated exact solution.
00297 *
00298                         CALL SGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00299      \$                               RESULT( 3 ) )
00300 *
00301 *+    TESTS 4, 5, and 6
00302 *                       Use iterative refinement to improve the solution
00303 *                       and compute error bounds.
00304 *
00305                         SRNAMT = 'STRRFS'
00306                         CALL STRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA,
00307      \$                               B, LDA, X, LDA, RWORK,
00308      \$                               RWORK( NRHS+1 ), WORK, IWORK,
00309      \$                               INFO )
00310 *
00311 *                       Check error code from STRRFS.
00312 *
00313                         IF( INFO.NE.0 )
00314      \$                     CALL ALAERH( PATH, 'STRRFS', INFO, 0,
00315      \$                                  UPLO // TRANS // DIAG, N, N, -1,
00316      \$                                  -1, NRHS, IMAT, NFAIL, NERRS,
00317      \$                                  NOUT )
00318 *
00319                         CALL SGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00320      \$                               RESULT( 4 ) )
00321                         CALL STRT05( UPLO, TRANS, DIAG, N, NRHS, A, LDA,
00322      \$                               B, LDA, X, LDA, XACT, LDA, RWORK,
00323      \$                               RWORK( NRHS+1 ), RESULT( 5 ) )
00324 *
00325 *                       Print information about the tests that did not
00326 *                       pass the threshold.
00327 *
00328                         DO 20 K = 2, 6
00329                            IF( RESULT( K ).GE.THRESH ) THEN
00330                               IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00331      \$                           CALL ALAHD( NOUT, PATH )
00332                               WRITE( NOUT, FMT = 9998 )UPLO, TRANS,
00333      \$                           DIAG, N, NRHS, IMAT, K, RESULT( K )
00334                               NFAIL = NFAIL + 1
00335                            END IF
00336    20                   CONTINUE
00337                         NRUN = NRUN + 5
00338    30                CONTINUE
00339    40             CONTINUE
00340 *
00341 *+    TEST 7
00342 *                       Get an estimate of RCOND = 1/CNDNUM.
00343 *
00344                   DO 50 ITRAN = 1, 2
00345                      IF( ITRAN.EQ.1 ) THEN
00346                         NORM = 'O'
00347                         RCONDC = RCONDO
00348                      ELSE
00349                         NORM = 'I'
00350                         RCONDC = RCONDI
00351                      END IF
00352                      SRNAMT = 'STRCON'
00353                      CALL STRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND,
00354      \$                            WORK, IWORK, INFO )
00355 *
00356 *                       Check error code from STRCON.
00357 *
00358                      IF( INFO.NE.0 )
00359      \$                  CALL ALAERH( PATH, 'STRCON', INFO, 0,
00360      \$                               NORM // UPLO // DIAG, N, N, -1, -1,
00361      \$                               -1, IMAT, NFAIL, NERRS, NOUT )
00362 *
00363                      CALL STRT06( RCOND, RCONDC, UPLO, DIAG, N, A, LDA,
00364      \$                            RWORK, RESULT( 7 ) )
00365 *
00366 *                    Print the test ratio if it is .GE. THRESH.
00367 *
00368                      IF( RESULT( 7 ).GE.THRESH ) THEN
00369                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00370      \$                     CALL ALAHD( NOUT, PATH )
00371                         WRITE( NOUT, FMT = 9997 )NORM, UPLO, N, IMAT,
00372      \$                     7, RESULT( 7 )
00373                         NFAIL = NFAIL + 1
00374                      END IF
00375                      NRUN = NRUN + 1
00376    50             CONTINUE
00377    60          CONTINUE
00378    70       CONTINUE
00379    80    CONTINUE
00380 *
00381 *        Use pathological test matrices to test SLATRS.
00382 *
00383          DO 110 IMAT = NTYPE1 + 1, NTYPES
00384 *
00385 *           Do the tests only if DOTYPE( IMAT ) is true.
00386 *
00387             IF( .NOT.DOTYPE( IMAT ) )
00388      \$         GO TO 110
00389 *
00390             DO 100 IUPLO = 1, 2
00391 *
00392 *              Do first for UPLO = 'U', then for UPLO = 'L'
00393 *
00394                UPLO = UPLOS( IUPLO )
00395                DO 90 ITRAN = 1, NTRAN
00396 *
00397 *                 Do for op(A) = A, A**T, and A**H.
00398 *
00399                   TRANS = TRANSS( ITRAN )
00400 *
00401 *                 Call SLATTR to generate a triangular test matrix.
00402 *
00403                   SRNAMT = 'SLATTR'
00404                   CALL SLATTR( IMAT, UPLO, TRANS, DIAG, ISEED, N, A,
00405      \$                         LDA, X, WORK, INFO )
00406 *
00407 *+    TEST 8
00408 *                 Solve the system op(A)*x = b.
00409 *
00410                   SRNAMT = 'SLATRS'
00411                   CALL SCOPY( N, X, 1, B, 1 )
00412                   CALL SLATRS( UPLO, TRANS, DIAG, 'N', N, A, LDA, B,
00413      \$                         SCALE, RWORK, INFO )
00414 *
00415 *                 Check error code from SLATRS.
00416 *
00417                   IF( INFO.NE.0 )
00418      \$               CALL ALAERH( PATH, 'SLATRS', INFO, 0,
00419      \$                            UPLO // TRANS // DIAG // 'N', N, N,
00420      \$                            -1, -1, -1, IMAT, NFAIL, NERRS, NOUT )
00421 *
00422                   CALL STRT03( UPLO, TRANS, DIAG, N, 1, A, LDA, SCALE,
00423      \$                         RWORK, ONE, B, LDA, X, LDA, WORK,
00424      \$                         RESULT( 8 ) )
00425 *
00426 *+    TEST 9
00427 *                 Solve op(A)*X = b again with NORMIN = 'Y'.
00428 *
00429                   CALL SCOPY( N, X, 1, B( N+1 ), 1 )
00430                   CALL SLATRS( UPLO, TRANS, DIAG, 'Y', N, A, LDA,
00431      \$                         B( N+1 ), SCALE, RWORK, INFO )
00432 *
00433 *                 Check error code from SLATRS.
00434 *
00435                   IF( INFO.NE.0 )
00436      \$               CALL ALAERH( PATH, 'SLATRS', INFO, 0,
00437      \$                            UPLO // TRANS // DIAG // 'Y', N, N,
00438      \$                            -1, -1, -1, IMAT, NFAIL, NERRS, NOUT )
00439 *
00440                   CALL STRT03( UPLO, TRANS, DIAG, N, 1, A, LDA, SCALE,
00441      \$                         RWORK, ONE, B( N+1 ), LDA, X, LDA, WORK,
00442      \$                         RESULT( 9 ) )
00443 *
00444 *                 Print information about the tests that did not pass
00445 *                 the threshold.
00446 *
00447                   IF( RESULT( 8 ).GE.THRESH ) THEN
00448                      IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00449      \$                  CALL ALAHD( NOUT, PATH )
00450                      WRITE( NOUT, FMT = 9996 )'SLATRS', UPLO, TRANS,
00451      \$                  DIAG, 'N', N, IMAT, 8, RESULT( 8 )
00452                      NFAIL = NFAIL + 1
00453                   END IF
00454                   IF( RESULT( 9 ).GE.THRESH ) THEN
00455                      IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00456      \$                  CALL ALAHD( NOUT, PATH )
00457                      WRITE( NOUT, FMT = 9996 )'SLATRS', UPLO, TRANS,
00458      \$                  DIAG, 'Y', N, IMAT, 9, RESULT( 9 )
00459                      NFAIL = NFAIL + 1
00460                   END IF
00461                   NRUN = NRUN + 2
00462    90          CONTINUE
00463   100       CONTINUE
00464   110    CONTINUE
00465   120 CONTINUE
00466 *
00467 *     Print a summary of the results.
00468 *
00469       CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS )
00470 *
00471  9999 FORMAT( ' UPLO=''', A1, ''', DIAG=''', A1, ''', N=', I5, ', NB=',
00472      \$      I4, ', type ', I2, ', test(', I2, ')= ', G12.5 )
00473  9998 FORMAT( ' UPLO=''', A1, ''', TRANS=''', A1, ''', DIAG=''', A1,
00474      \$      ''', N=', I5, ', NB=', I4, ', type ', I2,
00475 ',     \$      test(', I2, ')= ', G12.5 )
00476  9997 FORMAT( ' NORM=''', A1, ''', UPLO =''', A1, ''', N=', I5, ',',
00477      \$      11X, ' type ', I2, ', test(', I2, ')=', G12.5 )
00478  9996 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ''', A1, ''', ''',
00479      \$      A1, ''',', I5, ', ... ), type ', I2, ', test(', I2, ')=',
00480      \$      G12.5 )
00481       RETURN
00482 *
00483 *     End of SCHKTR
00484 *
00485       END
```