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