LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
schktb.f
Go to the documentation of this file.
00001 *> \brief \b SCHKTB
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 SCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00012 *                          NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK,
00013 *                          NOUT )
00014 * 
00015 *       .. Scalar Arguments ..
00016 *       LOGICAL            TSTERR
00017 *       INTEGER            NMAX, NN, NNS, NOUT
00018 *       REAL               THRESH
00019 *       ..
00020 *       .. Array Arguments ..
00021 *       LOGICAL            DOTYPE( * )
00022 *       INTEGER            IWORK( * ), NSVAL( * ), NVAL( * )
00023 *       REAL               AB( * ), AINV( * ), B( * ), RWORK( * ),
00024 *      $                   WORK( * ), X( * ), XACT( * )
00025 *       ..
00026 *  
00027 *
00028 *> \par Purpose:
00029 *  =============
00030 *>
00031 *> \verbatim
00032 *>
00033 *> SCHKTB tests STBTRS, -RFS, and -CON, and SLATBS.
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 column dimension N.
00057 *> \endverbatim
00058 *>
00059 *> \param[in] NNS
00060 *> \verbatim
00061 *>          NNS is INTEGER
00062 *>          The number of values of NRHS contained in the vector NSVAL.
00063 *> \endverbatim
00064 *>
00065 *> \param[in] NSVAL
00066 *> \verbatim
00067 *>          NSVAL is INTEGER array, dimension (NNS)
00068 *>          The values of the number of right hand sides NRHS.
00069 *> \endverbatim
00070 *>
00071 *> \param[in] THRESH
00072 *> \verbatim
00073 *>          THRESH is REAL
00074 *>          The threshold value for the test ratios.  A result is
00075 *>          included in the output file if RESULT >= THRESH.  To have
00076 *>          every test ratio printed, use THRESH = 0.
00077 *> \endverbatim
00078 *>
00079 *> \param[in] TSTERR
00080 *> \verbatim
00081 *>          TSTERR is LOGICAL
00082 *>          Flag that indicates whether error exits are to be tested.
00083 *> \endverbatim
00084 *>
00085 *> \param[in] NMAX
00086 *> \verbatim
00087 *>          NMAX is INTEGER
00088 *>          The leading dimension of the work arrays.
00089 *>          NMAX >= the maximum value of N in NVAL.
00090 *> \endverbatim
00091 *>
00092 *> \param[out] AB
00093 *> \verbatim
00094 *>          AB is REAL array, dimension (NMAX*NMAX)
00095 *> \endverbatim
00096 *>
00097 *> \param[out] AINV
00098 *> \verbatim
00099 *>          AINV is REAL array, dimension (NMAX*NMAX)
00100 *> \endverbatim
00101 *>
00102 *> \param[out] B
00103 *> \verbatim
00104 *>          B is REAL array, dimension (NMAX*NSMAX)
00105 *>          where NSMAX is the largest entry in NSVAL.
00106 *> \endverbatim
00107 *>
00108 *> \param[out] X
00109 *> \verbatim
00110 *>          X is REAL array, dimension (NMAX*NSMAX)
00111 *> \endverbatim
00112 *>
00113 *> \param[out] XACT
00114 *> \verbatim
00115 *>          XACT is REAL array, dimension (NMAX*NSMAX)
00116 *> \endverbatim
00117 *>
00118 *> \param[out] WORK
00119 *> \verbatim
00120 *>          WORK is REAL array, dimension
00121 *>                      (NMAX*max(3,NSMAX))
00122 *> \endverbatim
00123 *>
00124 *> \param[out] RWORK
00125 *> \verbatim
00126 *>          RWORK is REAL array, dimension
00127 *>                      (max(NMAX,2*NSMAX))
00128 *> \endverbatim
00129 *>
00130 *> \param[out] IWORK
00131 *> \verbatim
00132 *>          IWORK is INTEGER array, dimension (NMAX)
00133 *> \endverbatim
00134 *>
00135 *> \param[in] NOUT
00136 *> \verbatim
00137 *>          NOUT is INTEGER
00138 *>          The unit number for output.
00139 *> \endverbatim
00140 *
00141 *  Authors:
00142 *  ========
00143 *
00144 *> \author Univ. of Tennessee 
00145 *> \author Univ. of California Berkeley 
00146 *> \author Univ. of Colorado Denver 
00147 *> \author NAG Ltd. 
00148 *
00149 *> \date November 2011
00150 *
00151 *> \ingroup single_lin
00152 *
00153 *  =====================================================================
00154       SUBROUTINE SCHKTB( DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR,
00155      $                   NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK,
00156      $                   NOUT )
00157 *
00158 *  -- LAPACK test routine (version 3.4.0) --
00159 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00160 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00161 *     November 2011
00162 *
00163 *     .. Scalar Arguments ..
00164       LOGICAL            TSTERR
00165       INTEGER            NMAX, NN, NNS, NOUT
00166       REAL               THRESH
00167 *     ..
00168 *     .. Array Arguments ..
00169       LOGICAL            DOTYPE( * )
00170       INTEGER            IWORK( * ), NSVAL( * ), NVAL( * )
00171       REAL               AB( * ), AINV( * ), B( * ), RWORK( * ),
00172      $                   WORK( * ), X( * ), XACT( * )
00173 *     ..
00174 *
00175 *  =====================================================================
00176 *
00177 *     .. Parameters ..
00178       INTEGER            NTYPE1, NTYPES
00179       PARAMETER          ( NTYPE1 = 9, NTYPES = 17 )
00180       INTEGER            NTESTS
00181       PARAMETER          ( NTESTS = 8 )
00182       INTEGER            NTRAN
00183       PARAMETER          ( NTRAN = 3 )
00184       REAL               ONE, ZERO
00185       PARAMETER          ( ONE = 1.0E+0, ZERO = 0.0E+0 )
00186 *     ..
00187 *     .. Local Scalars ..
00188       CHARACTER          DIAG, NORM, TRANS, UPLO, XTYPE
00189       CHARACTER*3        PATH
00190       INTEGER            I, IDIAG, IK, IMAT, IN, INFO, IRHS, ITRAN,
00191      $                   IUPLO, J, K, KD, LDA, LDAB, N, NERRS, NFAIL,
00192      $                   NIMAT, NIMAT2, NK, NRHS, NRUN
00193       REAL               AINVNM, ANORM, RCOND, RCONDC, RCONDI, RCONDO,
00194      $                   SCALE
00195 *     ..
00196 *     .. Local Arrays ..
00197       CHARACTER          TRANSS( NTRAN ), UPLOS( 2 )
00198       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00199       REAL               RESULT( NTESTS )
00200 *     ..
00201 *     .. External Functions ..
00202       LOGICAL            LSAME
00203       REAL               SLANTB, SLANTR
00204       EXTERNAL           LSAME, SLANTB, SLANTR
00205 *     ..
00206 *     .. External Subroutines ..
00207       EXTERNAL           ALAERH, ALAHD, ALASUM, SCOPY, SERRTR, SGET04,
00208      $                   SLACPY, SLARHS, SLASET, SLATBS, SLATTB, STBCON,
00209      $                   STBRFS, STBSV, STBT02, STBT03, STBT05, STBT06,
00210      $                   STBTRS
00211 *     ..
00212 *     .. Scalars in Common ..
00213       LOGICAL            LERR, OK
00214       CHARACTER*32       SRNAMT
00215       INTEGER            INFOT, IOUNIT
00216 *     ..
00217 *     .. Common blocks ..
00218       COMMON             / INFOC / INFOT, IOUNIT, OK, LERR
00219       COMMON             / SRNAMC / SRNAMT
00220 *     ..
00221 *     .. Intrinsic Functions ..
00222       INTRINSIC          MAX, MIN
00223 *     ..
00224 *     .. Data statements ..
00225       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
00226       DATA               UPLOS / 'U', 'L' / , TRANSS / 'N', 'T', 'C' /
00227 *     ..
00228 *     .. Executable Statements ..
00229 *
00230 *     Initialize constants and the random number seed.
00231 *
00232       PATH( 1: 1 ) = 'Single precision'
00233       PATH( 2: 3 ) = 'TB'
00234       NRUN = 0
00235       NFAIL = 0
00236       NERRS = 0
00237       DO 10 I = 1, 4
00238          ISEED( I ) = ISEEDY( I )
00239    10 CONTINUE
00240 *
00241 *     Test the error exits
00242 *
00243       IF( TSTERR )
00244      $   CALL SERRTR( PATH, NOUT )
00245       INFOT = 0
00246 *
00247       DO 140 IN = 1, NN
00248 *
00249 *        Do for each value of N in NVAL
00250 *
00251          N = NVAL( IN )
00252          LDA = MAX( 1, N )
00253          XTYPE = 'N'
00254          NIMAT = NTYPE1
00255          NIMAT2 = NTYPES
00256          IF( N.LE.0 ) THEN
00257             NIMAT = 1
00258             NIMAT2 = NTYPE1 + 1
00259          END IF
00260 *
00261          NK = MIN( N+1, 4 )
00262          DO 130 IK = 1, NK
00263 *
00264 *           Do for KD = 0, N, (3N-1)/4, and (N+1)/4. This order makes
00265 *           it easier to skip redundant values for small values of N.
00266 *
00267             IF( IK.EQ.1 ) THEN
00268                KD = 0
00269             ELSE IF( IK.EQ.2 ) THEN
00270                KD = MAX( N, 0 )
00271             ELSE IF( IK.EQ.3 ) THEN
00272                KD = ( 3*N-1 ) / 4
00273             ELSE IF( IK.EQ.4 ) THEN
00274                KD = ( N+1 ) / 4
00275             END IF
00276             LDAB = KD + 1
00277 *
00278             DO 90 IMAT = 1, NIMAT
00279 *
00280 *              Do the tests only if DOTYPE( IMAT ) is true.
00281 *
00282                IF( .NOT.DOTYPE( IMAT ) )
00283      $            GO TO 90
00284 *
00285                DO 80 IUPLO = 1, 2
00286 *
00287 *                 Do first for UPLO = 'U', then for UPLO = 'L'
00288 *
00289                   UPLO = UPLOS( IUPLO )
00290 *
00291 *                 Call SLATTB to generate a triangular test matrix.
00292 *
00293                   SRNAMT = 'SLATTB'
00294                   CALL SLATTB( IMAT, UPLO, 'No transpose', DIAG, ISEED,
00295      $                         N, KD, AB, LDAB, X, WORK, INFO )
00296 *
00297 *                 Set IDIAG = 1 for non-unit matrices, 2 for unit.
00298 *
00299                   IF( LSAME( DIAG, 'N' ) ) THEN
00300                      IDIAG = 1
00301                   ELSE
00302                      IDIAG = 2
00303                   END IF
00304 *
00305 *                 Form the inverse of A so we can get a good estimate
00306 *                 of RCONDC = 1/(norm(A) * norm(inv(A))).
00307 *
00308                   CALL SLASET( 'Full', N, N, ZERO, ONE, AINV, LDA )
00309                   IF( LSAME( UPLO, 'U' ) ) THEN
00310                      DO 20 J = 1, N
00311                         CALL STBSV( UPLO, 'No transpose', DIAG, J, KD,
00312      $                              AB, LDAB, AINV( ( J-1 )*LDA+1 ), 1 )
00313    20                CONTINUE
00314                   ELSE
00315                      DO 30 J = 1, N
00316                         CALL STBSV( UPLO, 'No transpose', DIAG, N-J+1,
00317      $                              KD, AB( ( J-1 )*LDAB+1 ), LDAB,
00318      $                              AINV( ( J-1 )*LDA+J ), 1 )
00319    30                CONTINUE
00320                   END IF
00321 *
00322 *                 Compute the 1-norm condition number of A.
00323 *
00324                   ANORM = SLANTB( '1', UPLO, DIAG, N, KD, AB, LDAB,
00325      $                    RWORK )
00326                   AINVNM = SLANTR( '1', UPLO, DIAG, N, N, AINV, LDA,
00327      $                     RWORK )
00328                   IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00329                      RCONDO = ONE
00330                   ELSE
00331                      RCONDO = ( ONE / ANORM ) / AINVNM
00332                   END IF
00333 *
00334 *                 Compute the infinity-norm condition number of A.
00335 *
00336                   ANORM = SLANTB( 'I', UPLO, DIAG, N, KD, AB, LDAB,
00337      $                    RWORK )
00338                   AINVNM = SLANTR( 'I', UPLO, DIAG, N, N, AINV, LDA,
00339      $                     RWORK )
00340                   IF( ANORM.LE.ZERO .OR. AINVNM.LE.ZERO ) THEN
00341                      RCONDI = ONE
00342                   ELSE
00343                      RCONDI = ( ONE / ANORM ) / AINVNM
00344                   END IF
00345 *
00346                   DO 60 IRHS = 1, NNS
00347                      NRHS = NSVAL( IRHS )
00348                      XTYPE = 'N'
00349 *
00350                      DO 50 ITRAN = 1, NTRAN
00351 *
00352 *                    Do for op(A) = A, A**T, or A**H.
00353 *
00354                         TRANS = TRANSS( ITRAN )
00355                         IF( ITRAN.EQ.1 ) THEN
00356                            NORM = 'O'
00357                            RCONDC = RCONDO
00358                         ELSE
00359                            NORM = 'I'
00360                            RCONDC = RCONDI
00361                         END IF
00362 *
00363 *+    TEST 1
00364 *                    Solve and compute residual for op(A)*x = b.
00365 *
00366                         SRNAMT = 'SLARHS'
00367                         CALL SLARHS( PATH, XTYPE, UPLO, TRANS, N, N, KD,
00368      $                               IDIAG, NRHS, AB, LDAB, XACT, LDA,
00369      $                               B, LDA, ISEED, INFO )
00370                         XTYPE = 'C'
00371                         CALL SLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00372 *
00373                         SRNAMT = 'STBTRS'
00374                         CALL STBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB,
00375      $                               LDAB, X, LDA, INFO )
00376 *
00377 *                    Check error code from STBTRS.
00378 *
00379                         IF( INFO.NE.0 )
00380      $                     CALL ALAERH( PATH, 'STBTRS', INFO, 0,
00381      $                                  UPLO // TRANS // DIAG, N, N, KD,
00382      $                                  KD, NRHS, IMAT, NFAIL, NERRS,
00383      $                                  NOUT )
00384 *
00385                         CALL STBT02( UPLO, TRANS, DIAG, N, KD, NRHS, AB,
00386      $                               LDAB, X, LDA, B, LDA, WORK,
00387      $                               RESULT( 1 ) )
00388 *
00389 *+    TEST 2
00390 *                    Check solution from generated exact solution.
00391 *
00392                         CALL SGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00393      $                               RESULT( 2 ) )
00394 *
00395 *+    TESTS 3, 4, and 5
00396 *                    Use iterative refinement to improve the solution
00397 *                    and compute error bounds.
00398 *
00399                         SRNAMT = 'STBRFS'
00400                         CALL STBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB,
00401      $                               LDAB, B, LDA, X, LDA, RWORK,
00402      $                               RWORK( NRHS+1 ), WORK, IWORK,
00403      $                               INFO )
00404 *
00405 *                    Check error code from STBRFS.
00406 *
00407                         IF( INFO.NE.0 )
00408      $                     CALL ALAERH( PATH, 'STBRFS', INFO, 0,
00409      $                                  UPLO // TRANS // DIAG, N, N, KD,
00410      $                                  KD, NRHS, IMAT, NFAIL, NERRS,
00411      $                                  NOUT )
00412 *
00413                         CALL SGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00414      $                               RESULT( 3 ) )
00415                         CALL STBT05( UPLO, TRANS, DIAG, N, KD, NRHS, AB,
00416      $                               LDAB, B, LDA, X, LDA, XACT, LDA,
00417      $                               RWORK, RWORK( NRHS+1 ),
00418      $                               RESULT( 4 ) )
00419 *
00420 *                       Print information about the tests that did not
00421 *                       pass the threshold.
00422 *
00423                         DO 40 K = 1, 5
00424                            IF( RESULT( K ).GE.THRESH ) THEN
00425                               IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00426      $                           CALL ALAHD( NOUT, PATH )
00427                               WRITE( NOUT, FMT = 9999 )UPLO, TRANS,
00428      $                           DIAG, N, KD, NRHS, IMAT, K, RESULT( K )
00429                               NFAIL = NFAIL + 1
00430                            END IF
00431    40                   CONTINUE
00432                         NRUN = NRUN + 5
00433    50                CONTINUE
00434    60             CONTINUE
00435 *
00436 *+    TEST 6
00437 *                    Get an estimate of RCOND = 1/CNDNUM.
00438 *
00439                   DO 70 ITRAN = 1, 2
00440                      IF( ITRAN.EQ.1 ) THEN
00441                         NORM = 'O'
00442                         RCONDC = RCONDO
00443                      ELSE
00444                         NORM = 'I'
00445                         RCONDC = RCONDI
00446                      END IF
00447                      SRNAMT = 'STBCON'
00448                      CALL STBCON( NORM, UPLO, DIAG, N, KD, AB, LDAB,
00449      $                            RCOND, WORK, IWORK, INFO )
00450 *
00451 *                    Check error code from STBCON.
00452 *
00453                      IF( INFO.NE.0 )
00454      $                  CALL ALAERH( PATH, 'STBCON', INFO, 0,
00455      $                               NORM // UPLO // DIAG, N, N, KD, KD,
00456      $                               -1, IMAT, NFAIL, NERRS, NOUT )
00457 *
00458                      CALL STBT06( RCOND, RCONDC, UPLO, DIAG, N, KD, AB,
00459      $                            LDAB, RWORK, RESULT( 6 ) )
00460 *
00461 *                    Print information about the tests that did not pass
00462 *                    the threshold.
00463 *
00464                      IF( RESULT( 6 ).GE.THRESH ) THEN
00465                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00466      $                     CALL ALAHD( NOUT, PATH )
00467                         WRITE( NOUT, FMT = 9998 ) 'STBCON', NORM, UPLO,
00468      $                     DIAG, N, KD, IMAT, 6, RESULT( 6 )
00469                         NFAIL = NFAIL + 1
00470                      END IF
00471                      NRUN = NRUN + 1
00472    70             CONTINUE
00473    80          CONTINUE
00474    90       CONTINUE
00475 *
00476 *           Use pathological test matrices to test SLATBS.
00477 *
00478             DO 120 IMAT = NTYPE1 + 1, NIMAT2
00479 *
00480 *              Do the tests only if DOTYPE( IMAT ) is true.
00481 *
00482                IF( .NOT.DOTYPE( IMAT ) )
00483      $            GO TO 120
00484 *
00485                DO 110 IUPLO = 1, 2
00486 *
00487 *                 Do first for UPLO = 'U', then for UPLO = 'L'
00488 *
00489                   UPLO = UPLOS( IUPLO )
00490                   DO 100 ITRAN = 1, NTRAN
00491 *
00492 *                    Do for op(A) = A, A**T, and A**H.
00493 *
00494                      TRANS = TRANSS( ITRAN )
00495 *
00496 *                    Call SLATTB to generate a triangular test matrix.
00497 *
00498                      SRNAMT = 'SLATTB'
00499                      CALL SLATTB( IMAT, UPLO, TRANS, DIAG, ISEED, N, KD,
00500      $                            AB, LDAB, X, WORK, INFO )
00501 *
00502 *+    TEST 7
00503 *                    Solve the system op(A)*x = b
00504 *
00505                      SRNAMT = 'SLATBS'
00506                      CALL SCOPY( N, X, 1, B, 1 )
00507                      CALL SLATBS( UPLO, TRANS, DIAG, 'N', N, KD, AB,
00508      $                            LDAB, B, SCALE, RWORK, INFO )
00509 *
00510 *                    Check error code from SLATBS.
00511 *
00512                      IF( INFO.NE.0 )
00513      $                  CALL ALAERH( PATH, 'SLATBS', INFO, 0,
00514      $                               UPLO // TRANS // DIAG // 'N', N, N,
00515      $                               KD, KD, -1, IMAT, NFAIL, NERRS,
00516      $                               NOUT )
00517 *
00518                      CALL STBT03( UPLO, TRANS, DIAG, N, KD, 1, AB, LDAB,
00519      $                            SCALE, RWORK, ONE, B, LDA, X, LDA,
00520      $                            WORK, RESULT( 7 ) )
00521 *
00522 *+    TEST 8
00523 *                    Solve op(A)*x = b again with NORMIN = 'Y'.
00524 *
00525                      CALL SCOPY( N, X, 1, B, 1 )
00526                      CALL SLATBS( UPLO, TRANS, DIAG, 'Y', N, KD, AB,
00527      $                            LDAB, B, SCALE, RWORK, INFO )
00528 *
00529 *                    Check error code from SLATBS.
00530 *
00531                      IF( INFO.NE.0 )
00532      $                  CALL ALAERH( PATH, 'SLATBS', INFO, 0,
00533      $                               UPLO // TRANS // DIAG // 'Y', N, N,
00534      $                               KD, KD, -1, IMAT, NFAIL, NERRS,
00535      $                               NOUT )
00536 *
00537                      CALL STBT03( UPLO, TRANS, DIAG, N, KD, 1, AB, LDAB,
00538      $                            SCALE, RWORK, ONE, B, LDA, X, LDA,
00539      $                            WORK, RESULT( 8 ) )
00540 *
00541 *                    Print information about the tests that did not pass
00542 *                    the threshold.
00543 *
00544                      IF( RESULT( 7 ).GE.THRESH ) THEN
00545                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00546      $                     CALL ALAHD( NOUT, PATH )
00547                         WRITE( NOUT, FMT = 9997 )'SLATBS', UPLO, TRANS,
00548      $                     DIAG, 'N', N, KD, IMAT, 7, RESULT( 7 )
00549                         NFAIL = NFAIL + 1
00550                      END IF
00551                      IF( RESULT( 8 ).GE.THRESH ) THEN
00552                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00553      $                     CALL ALAHD( NOUT, PATH )
00554                         WRITE( NOUT, FMT = 9997 )'SLATBS', UPLO, TRANS,
00555      $                     DIAG, 'Y', N, KD, IMAT, 8, RESULT( 8 )
00556                         NFAIL = NFAIL + 1
00557                      END IF
00558                      NRUN = NRUN + 2
00559   100             CONTINUE
00560   110          CONTINUE
00561   120       CONTINUE
00562   130    CONTINUE
00563   140 CONTINUE
00564 *
00565 *     Print a summary of the results.
00566 *
00567       CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS )
00568 *
00569  9999 FORMAT( ' UPLO=''', A1, ''', TRANS=''', A1, ''
00570 ',     $      DIAG=''', A1, ''', N=', I5, ', KD=', I5, ', NRHS=', I5,
00571      $      ', type ', I2, ', test(', I2, ')=', G12.5 )
00572  9998 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ''', A1, ''',',
00573      $      I5, ',', I5, ',  ... ), type ', I2, ', test(', I2, ')=',
00574      $      G12.5 )
00575  9997 FORMAT( 1X, A, '( ''', A1, ''', ''', A1, ''', ''', A1, ''', ''',
00576      $      A1, ''',', I5, ',', I5, ', ...  ),  type ', I2, ', test(',
00577      $      I1, ')=', G12.5 )
00578       RETURN
00579 *
00580 *     End of SCHKTB
00581 *
00582       END
 All Files Functions