LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
zchkhe.f
Go to the documentation of this file.
00001 *> \brief \b ZCHKHE
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 ZCHKHE( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
00012 *                          THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
00013 *                          XACT, WORK, RWORK, IWORK, 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            IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
00023 *       DOUBLE PRECISION   RWORK( * )
00024 *       COMPLEX*16         A( * ), AFAC( * ), AINV( * ), B( * ),
00025 *      $                   WORK( * ), X( * ), XACT( * )
00026 *       ..
00027 *  
00028 *
00029 *> \par Purpose:
00030 *  =============
00031 *>
00032 *> \verbatim
00033 *>
00034 *> ZCHKHE tests ZHETRF, -TRI2, -TRS, -TRS2, -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] 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 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 (NBVAL)
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 maximum value permitted for N, used in dimensioning the
00102 *>          work arrays.
00103 *> \endverbatim
00104 *>
00105 *> \param[out] A
00106 *> \verbatim
00107 *>          A is COMPLEX*16 array, dimension (NMAX*NMAX)
00108 *> \endverbatim
00109 *>
00110 *> \param[out] AFAC
00111 *> \verbatim
00112 *>          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
00113 *> \endverbatim
00114 *>
00115 *> \param[out] AINV
00116 *> \verbatim
00117 *>          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
00118 *> \endverbatim
00119 *>
00120 *> \param[out] B
00121 *> \verbatim
00122 *>          B is COMPLEX*16 array, dimension (NMAX*NSMAX)
00123 *>          where NSMAX is the largest entry in NSVAL.
00124 *> \endverbatim
00125 *>
00126 *> \param[out] X
00127 *> \verbatim
00128 *>          X is COMPLEX*16 array, dimension (NMAX*NSMAX)
00129 *> \endverbatim
00130 *>
00131 *> \param[out] XACT
00132 *> \verbatim
00133 *>          XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
00134 *> \endverbatim
00135 *>
00136 *> \param[out] WORK
00137 *> \verbatim
00138 *>          WORK is COMPLEX*16 array, dimension
00139 *>                      (NMAX*max(3,NSMAX))
00140 *> \endverbatim
00141 *>
00142 *> \param[out] RWORK
00143 *> \verbatim
00144 *>          RWORK is DOUBLE PRECISION array, dimension
00145 *>                      (max(NMAX,2*NSMAX))
00146 *> \endverbatim
00147 *>
00148 *> \param[out] IWORK
00149 *> \verbatim
00150 *>          IWORK is INTEGER array, dimension (NMAX)
00151 *> \endverbatim
00152 *>
00153 *> \param[in] NOUT
00154 *> \verbatim
00155 *>          NOUT is INTEGER
00156 *>          The unit number for output.
00157 *> \endverbatim
00158 *
00159 *  Authors:
00160 *  ========
00161 *
00162 *> \author Univ. of Tennessee 
00163 *> \author Univ. of California Berkeley 
00164 *> \author Univ. of Colorado Denver 
00165 *> \author NAG Ltd. 
00166 *
00167 *> \date November 2011
00168 *
00169 *> \ingroup complex16_lin
00170 *
00171 *  =====================================================================
00172       SUBROUTINE ZCHKHE( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
00173      $                   THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
00174      $                   XACT, WORK, RWORK, IWORK, NOUT )
00175 *
00176 *  -- LAPACK test routine (version 3.4.0) --
00177 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00178 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00179 *     November 2011
00180 *
00181 *     .. Scalar Arguments ..
00182       LOGICAL            TSTERR
00183       INTEGER            NMAX, NN, NNB, NNS, NOUT
00184       DOUBLE PRECISION   THRESH
00185 *     ..
00186 *     .. Array Arguments ..
00187       LOGICAL            DOTYPE( * )
00188       INTEGER            IWORK( * ), NBVAL( * ), NSVAL( * ), NVAL( * )
00189       DOUBLE PRECISION   RWORK( * )
00190       COMPLEX*16         A( * ), AFAC( * ), AINV( * ), B( * ),
00191      $                   WORK( * ), X( * ), XACT( * )
00192 *     ..
00193 *
00194 *  =====================================================================
00195 *
00196 *     .. Parameters ..
00197       DOUBLE PRECISION   ZERO
00198       PARAMETER          ( ZERO = 0.0D+0 )
00199       INTEGER            NTYPES
00200       PARAMETER          ( NTYPES = 10 )
00201       INTEGER            NTESTS
00202       PARAMETER          ( NTESTS = 9 )
00203 *     ..
00204 *     .. Local Scalars ..
00205       LOGICAL            TRFCON, ZEROT
00206       CHARACTER          DIST, TYPE, UPLO, XTYPE
00207       CHARACTER*3        PATH
00208       INTEGER            I, I1, I2, IMAT, IN, INB, INFO, IOFF, IRHS,
00209      $                   IUPLO, IZERO, J, K, KL, KU, LDA, LWORK, MODE,
00210      $                   N, NB, NERRS, NFAIL, NIMAT, NRHS, NRUN, NT
00211       DOUBLE PRECISION   ANORM, CNDNUM, RCOND, RCONDC
00212 *     ..
00213 *     .. Local Arrays ..
00214       CHARACTER          UPLOS( 2 )
00215       INTEGER            ISEED( 4 ), ISEEDY( 4 )
00216       DOUBLE PRECISION   RESULT( NTESTS )
00217 *     ..
00218 *     .. External Functions ..
00219       DOUBLE PRECISION   DGET06, ZLANHE
00220       EXTERNAL           DGET06, ZLANHE
00221 *     ..
00222 *     .. External Subroutines ..
00223       EXTERNAL           ALAERH, ALAHD, ALASUM, XLAENV, ZERRHE, ZGET04,
00224      $                   ZHECON, ZHERFS, ZHET01, ZHETRF, ZHETRI2,
00225      $                   ZHETRS, ZLACPY, ZLAIPD, ZLARHS, ZLATB4, ZLATMS,
00226      $                   ZPOT02, ZPOT03, ZPOT05
00227 *     ..
00228 *     .. Intrinsic Functions ..
00229       INTRINSIC          MAX, MIN
00230 *     ..
00231 *     .. Scalars in Common ..
00232       LOGICAL            LERR, OK
00233       CHARACTER*32       SRNAMT
00234       INTEGER            INFOT, NUNIT
00235 *     ..
00236 *     .. Common blocks ..
00237       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
00238       COMMON             / SRNAMC / SRNAMT
00239 *     ..
00240 *     .. Data statements ..
00241       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
00242       DATA               UPLOS / 'U', 'L' /
00243 *     ..
00244 *     .. Executable Statements ..
00245 *
00246 *     Initialize constants and the random number seed.
00247 *
00248       PATH( 1: 1 ) = 'Zomplex precision'
00249       PATH( 2: 3 ) = 'HE'
00250       NRUN = 0
00251       NFAIL = 0
00252       NERRS = 0
00253       DO 10 I = 1, 4
00254          ISEED( I ) = ISEEDY( I )
00255    10 CONTINUE
00256 *
00257 *     Test the error exits
00258 *
00259       IF( TSTERR )
00260      $   CALL ZERRHE( PATH, NOUT )
00261       INFOT = 0
00262 *
00263 *     Do for each value of N in NVAL
00264 *
00265       DO 180 IN = 1, NN
00266          N = NVAL( IN )
00267          LDA = MAX( N, 1 )
00268          XTYPE = 'N'
00269          NIMAT = NTYPES
00270          IF( N.LE.0 )
00271      $      NIMAT = 1
00272 *
00273          IZERO = 0
00274          DO 170 IMAT = 1, NIMAT
00275 *
00276 *           Do the tests only if DOTYPE( IMAT ) is true.
00277 *
00278             IF( .NOT.DOTYPE( IMAT ) )
00279      $         GO TO 170
00280 *
00281 *           Skip types 3, 4, 5, or 6 if the matrix size is too small.
00282 *
00283             ZEROT = IMAT.GE.3 .AND. IMAT.LE.6
00284             IF( ZEROT .AND. N.LT.IMAT-2 )
00285      $         GO TO 170
00286 *
00287 *           Do first for UPLO = 'U', then for UPLO = 'L'
00288 *
00289             DO 160 IUPLO = 1, 2
00290                UPLO = UPLOS( IUPLO )
00291 *
00292 *              Set up parameters with ZLATB4 and generate a test matrix
00293 *              with ZLATMS.
00294 *
00295                CALL ZLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00296      $                      CNDNUM, DIST )
00297 *
00298                SRNAMT = 'ZLATMS'
00299                CALL ZLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
00300      $                      CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
00301      $                      INFO )
00302 *
00303 *              Check error code from ZLATMS.
00304 *
00305                IF( INFO.NE.0 ) THEN
00306                   CALL ALAERH( PATH, 'ZLATMS', INFO, 0, UPLO, N, N, -1,
00307      $                         -1, -1, IMAT, NFAIL, NERRS, NOUT )
00308                   GO TO 160
00309                END IF
00310 *
00311 *              For types 3-6, zero one or more rows and columns of
00312 *              the matrix to test that INFO is returned correctly.
00313 *
00314                IF( ZEROT ) THEN
00315                   IF( IMAT.EQ.3 ) THEN
00316                      IZERO = 1
00317                   ELSE IF( IMAT.EQ.4 ) THEN
00318                      IZERO = N
00319                   ELSE
00320                      IZERO = N / 2 + 1
00321                   END IF
00322 *
00323                   IF( IMAT.LT.6 ) THEN
00324 *
00325 *                    Set row and column IZERO to zero.
00326 *
00327                      IF( IUPLO.EQ.1 ) THEN
00328                         IOFF = ( IZERO-1 )*LDA
00329                         DO 20 I = 1, IZERO - 1
00330                            A( IOFF+I ) = ZERO
00331    20                   CONTINUE
00332                         IOFF = IOFF + IZERO
00333                         DO 30 I = IZERO, N
00334                            A( IOFF ) = ZERO
00335                            IOFF = IOFF + LDA
00336    30                   CONTINUE
00337                      ELSE
00338                         IOFF = IZERO
00339                         DO 40 I = 1, IZERO - 1
00340                            A( IOFF ) = ZERO
00341                            IOFF = IOFF + LDA
00342    40                   CONTINUE
00343                         IOFF = IOFF - IZERO
00344                         DO 50 I = IZERO, N
00345                            A( IOFF+I ) = ZERO
00346    50                   CONTINUE
00347                      END IF
00348                   ELSE
00349                      IOFF = 0
00350                      IF( IUPLO.EQ.1 ) THEN
00351 *
00352 *                       Set the first IZERO rows and columns to zero.
00353 *
00354                         DO 70 J = 1, N
00355                            I2 = MIN( J, IZERO )
00356                            DO 60 I = 1, I2
00357                               A( IOFF+I ) = ZERO
00358    60                      CONTINUE
00359                            IOFF = IOFF + LDA
00360    70                   CONTINUE
00361                      ELSE
00362 *
00363 *                       Set the last IZERO rows and columns to zero.
00364 *
00365                         DO 90 J = 1, N
00366                            I1 = MAX( J, IZERO )
00367                            DO 80 I = I1, N
00368                               A( IOFF+I ) = ZERO
00369    80                      CONTINUE
00370                            IOFF = IOFF + LDA
00371    90                   CONTINUE
00372                      END IF
00373                   END IF
00374                ELSE
00375                   IZERO = 0
00376                END IF
00377 *
00378 *              Set the imaginary part of the diagonals.
00379 *
00380                CALL ZLAIPD( N, A, LDA+1, 0 )
00381 *
00382 *              Do for each value of NB in NBVAL
00383 *
00384                DO 150 INB = 1, NNB
00385                   NB = NBVAL( INB )
00386                   CALL XLAENV( 1, NB )
00387 *
00388 *                 Compute the L*D*L' or U*D*U' factorization of the
00389 *                 matrix.
00390 *
00391                   CALL ZLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
00392                   LWORK = MAX( 2, NB )*LDA
00393                   SRNAMT = 'ZHETRF'
00394                   CALL ZHETRF( UPLO, N, AFAC, LDA, IWORK, AINV, LWORK,
00395      $                         INFO )
00396 *
00397 *                 Adjust the expected value of INFO to account for
00398 *                 pivoting.
00399 *
00400                   K = IZERO
00401                   IF( K.GT.0 ) THEN
00402   100                CONTINUE
00403                      IF( IWORK( K ).LT.0 ) THEN
00404                         IF( IWORK( K ).NE.-K ) THEN
00405                            K = -IWORK( K )
00406                            GO TO 100
00407                         END IF
00408                      ELSE IF( IWORK( K ).NE.K ) THEN
00409                         K = IWORK( K )
00410                         GO TO 100
00411                      END IF
00412                   END IF
00413 *
00414 *                 Check error code from ZHETRF.
00415 *
00416                   IF( INFO.NE.K )
00417      $               CALL ALAERH( PATH, 'ZHETRF', INFO, K, UPLO, N, N,
00418      $                            -1, -1, NB, IMAT, NFAIL, NERRS, NOUT )
00419                   IF( INFO.NE.0 ) THEN
00420                      TRFCON = .TRUE.
00421                   ELSE
00422                      TRFCON = .FALSE.
00423                   END IF
00424 *
00425 *+    TEST 1
00426 *                 Reconstruct matrix from factors and compute residual.
00427 *
00428                   CALL ZHET01( UPLO, N, A, LDA, AFAC, LDA, IWORK, AINV,
00429      $                         LDA, RWORK, RESULT( 1 ) )
00430                   NT = 1
00431 *
00432 *+    TEST 2
00433 *                 Form the inverse and compute the residual.
00434 *
00435                   IF( INB.EQ.1 .AND. .NOT.TRFCON ) THEN
00436                      CALL ZLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA )
00437                      SRNAMT = 'ZHETRI2'
00438                      LWORK = (N+NB+1)*(NB+3)
00439                      CALL ZHETRI2( UPLO, N, AINV, LDA, IWORK, WORK,
00440      $                            LWORK, INFO )
00441 *
00442 *                 Check error code from ZHETRI.
00443 *
00444                      IF( INFO.NE.0 )
00445      $                  CALL ALAERH( PATH, 'ZHETRI', INFO, -1, UPLO, N,
00446      $                               N, -1, -1, -1, IMAT, NFAIL, NERRS,
00447      $                               NOUT )
00448 *
00449                      CALL ZPOT03( UPLO, N, A, LDA, AINV, LDA, WORK, LDA,
00450      $                            RWORK, RCONDC, RESULT( 2 ) )
00451                      NT = 2
00452                   END IF
00453 *
00454 *                 Print information about the tests that did not pass
00455 *                 the threshold.
00456 *
00457                   DO 110 K = 1, NT
00458                      IF( RESULT( K ).GE.THRESH ) THEN
00459                         IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00460      $                     CALL ALAHD( NOUT, PATH )
00461                         WRITE( NOUT, FMT = 9999 )UPLO, N, NB, IMAT, K,
00462      $                     RESULT( K )
00463                         NFAIL = NFAIL + 1
00464                      END IF
00465   110             CONTINUE
00466                   NRUN = NRUN + NT
00467 *
00468 *                 Skip the other tests if this is not the first block
00469 *                 size.
00470 *
00471                   IF( INB.GT.1 )
00472      $               GO TO 150
00473 *
00474 *                 Do only the condition estimate if INFO is not 0.
00475 *
00476                   IF( TRFCON ) THEN
00477                      RCONDC = ZERO
00478                      GO TO 140
00479                   END IF
00480 *
00481                   DO 130 IRHS = 1, NNS
00482                      NRHS = NSVAL( IRHS )
00483 *
00484 *+    TEST 3
00485 *                 Solve and compute residual for  A * X = B.
00486 *
00487                      SRNAMT = 'ZLARHS'
00488                      CALL ZLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
00489      $                            NRHS, A, LDA, XACT, LDA, B, LDA,
00490      $                            ISEED, INFO )
00491                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00492 *
00493                      SRNAMT = 'ZHETRS'
00494                      CALL ZHETRS( UPLO, N, NRHS, AFAC, LDA, IWORK, X,
00495      $                            LDA, INFO )
00496 *
00497 *                 Check error code from ZHETRS.
00498 *
00499                      IF( INFO.NE.0 )
00500      $                  CALL ALAERH( PATH, 'ZHETRS', INFO, 0, UPLO, N,
00501      $                               N, -1, -1, NRHS, IMAT, NFAIL,
00502      $                               NERRS, NOUT )
00503 *
00504                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
00505                      CALL ZPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
00506      $                            LDA, RWORK, RESULT( 3 ) )
00507 *
00508 *+    TEST 4
00509 *                 Solve and compute residual for  A * X = B.
00510 *
00511                      SRNAMT = 'ZLARHS'
00512                      CALL ZLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
00513      $                            NRHS, A, LDA, XACT, LDA, B, LDA,
00514      $                            ISEED, INFO )
00515                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
00516 *
00517                      SRNAMT = 'ZHETRS2'
00518                      CALL ZHETRS2( UPLO, N, NRHS, AFAC, LDA, IWORK, X,
00519      $                            LDA, WORK, INFO )
00520 *
00521 *                 Check error code from ZSYTRS2.
00522 *
00523                      IF( INFO.NE.0 )
00524      $                  CALL ALAERH( PATH, 'ZHETRS2', INFO, 0, UPLO, N,
00525      $                               N, -1, -1, NRHS, IMAT, NFAIL,
00526      $                               NERRS, NOUT )
00527 *
00528                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
00529                      CALL ZPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
00530      $                            LDA, RWORK, RESULT( 4 ) )
00531 *
00532 *+    TEST 5
00533 *                 Check solution from generated exact solution.
00534 *
00535                      CALL ZGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00536      $                            RESULT( 5 ) )
00537 *
00538 *+    TESTS 6, 7, and 8
00539 *                 Use iterative refinement to improve the solution.
00540 *
00541                      SRNAMT = 'ZHERFS'
00542                      CALL ZHERFS( UPLO, N, NRHS, A, LDA, AFAC, LDA,
00543      $                            IWORK, B, LDA, X, LDA, RWORK,
00544      $                            RWORK( NRHS+1 ), WORK,
00545      $                            RWORK( 2*NRHS+1 ), INFO )
00546 *
00547 *                 Check error code from ZHERFS.
00548 *
00549                      IF( INFO.NE.0 )
00550      $                  CALL ALAERH( PATH, 'ZHERFS', INFO, 0, UPLO, N,
00551      $                               N, -1, -1, NRHS, IMAT, NFAIL,
00552      $                               NERRS, NOUT )
00553 *
00554                      CALL ZGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
00555      $                            RESULT( 6 ) )
00556                      CALL ZPOT05( UPLO, N, NRHS, A, LDA, B, LDA, X, LDA,
00557      $                            XACT, LDA, RWORK, RWORK( NRHS+1 ),
00558      $                            RESULT( 7 ) )
00559 *
00560 *                    Print information about the tests that did not pass
00561 *                    the threshold.
00562 *
00563                      DO 120 K = 3, 8
00564                         IF( RESULT( K ).GE.THRESH ) THEN
00565                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00566      $                        CALL ALAHD( NOUT, PATH )
00567                            WRITE( NOUT, FMT = 9998 )UPLO, N, NRHS,
00568      $                        IMAT, K, RESULT( K )
00569                            NFAIL = NFAIL + 1
00570                         END IF
00571   120                CONTINUE
00572                      NRUN = NRUN + 5
00573   130             CONTINUE
00574 *
00575 *+    TEST 9
00576 *                 Get an estimate of RCOND = 1/CNDNUM.
00577 *
00578   140             CONTINUE
00579                   ANORM = ZLANHE( '1', UPLO, N, A, LDA, RWORK )
00580                   SRNAMT = 'ZHECON'
00581                   CALL ZHECON( UPLO, N, AFAC, LDA, IWORK, ANORM, RCOND,
00582      $                         WORK, INFO )
00583 *
00584 *                 Check error code from ZHECON.
00585 *
00586                   IF( INFO.NE.0 )
00587      $               CALL ALAERH( PATH, 'ZHECON', INFO, 0, UPLO, N, N,
00588      $                            -1, -1, -1, IMAT, NFAIL, NERRS, NOUT )
00589 *
00590                   RESULT( 9 ) = DGET06( RCOND, RCONDC )
00591 *
00592 *                 Print information about the tests that did not pass
00593 *                 the threshold.
00594 *
00595                   IF( RESULT( 9 ).GE.THRESH ) THEN
00596                      IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
00597      $                  CALL ALAHD( NOUT, PATH )
00598                      WRITE( NOUT, FMT = 9997 )UPLO, N, IMAT, 9,
00599      $                  RESULT( 9 )
00600                      NFAIL = NFAIL + 1
00601                   END IF
00602                   NRUN = NRUN + 1
00603   150          CONTINUE
00604   160       CONTINUE
00605   170    CONTINUE
00606   180 CONTINUE
00607 *
00608 *     Print a summary of the results.
00609 *
00610       CALL ALASUM( PATH, NOUT, NFAIL, NRUN, NERRS )
00611 *
00612  9999 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ', NB =', I4, ', type ',
00613      $      I2, ', test ', I2, ', ratio =', G12.5 )
00614  9998 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ', NRHS=', I3, ', type ',
00615      $      I2, ', test(', I2, ') =', G12.5 )
00616  9997 FORMAT( ' UPLO = ''', A1, ''', N =', I5, ',', 10X, ' type ', I2,
00617      $      ', test(', I2, ') =', G12.5 )
00618       RETURN
00619 *
00620 *     End of ZCHKHE
00621 *
00622       END
 All Files Functions