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