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