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