zdrvst.f (flens/lapack/test/EIG/zdrvst.f)

   1       SUBROUTINE ZDRVST( NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH,

   2      $                   NOUNIT, A, LDA, D1, D2, D3, WA1, WA2, WA3, U,

   3      $                   LDU, V, TAU, Z, WORK, LWORK, RWORK, LRWORK,

   4      $                   IWORK, LIWORK, RESULT, INFO )

   5 *

   6 *  -- LAPACK test routine (version 3.1) --

   7 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..

   8 *     November 2006

   9 *

  10 *     .. Scalar Arguments ..

  11       INTEGER            INFO, LDA, LDU, LIWORK, LRWORK, LWORK, NOUNIT,

  12      $                   NSIZES, NTYPES

  13       DOUBLE PRECISION   THRESH

  14 *     ..

  15 *     .. Array Arguments ..

  16       LOGICAL            DOTYPE( * )

  17       INTEGER            ISEED( 4 ), IWORK( * ), NN( * )

  18       DOUBLE PRECISION   D1( * ), D2( * ), D3( * ), RESULT( * ),

  19      $                   RWORK( * ), WA1( * ), WA2( * ), WA3( * )

  20       COMPLEX*16         A( LDA, * ), TAU( * ), U( LDU, * ),

  21      $                   V( LDU, * ), WORK( * ), Z( LDU, * )

  22 *     ..

  23 *

  24 *  Purpose

  25 *  =======

  26 *

  27 *       ZDRVST  checks the Hermitian eigenvalue problem drivers.

  28 *

  29 *               ZHEEVD computes all eigenvalues and, optionally,

  30 *               eigenvectors of a complex Hermitian matrix,

  31 *               using a divide-and-conquer algorithm.

  32 *

  33 *               ZHEEVX computes selected eigenvalues and, optionally,

  34 *               eigenvectors of a complex Hermitian matrix.

  35 *

  36 *               ZHEEVR computes selected eigenvalues and, optionally,

  37 *               eigenvectors of a complex Hermitian matrix

  38 *               using the Relatively Robust Representation where it can.

  39 *

  40 *               ZHPEVD computes all eigenvalues and, optionally,

  41 *               eigenvectors of a complex Hermitian matrix in packed

  42 *               storage, using a divide-and-conquer algorithm.

  43 *

  44 *               ZHPEVX computes selected eigenvalues and, optionally,

  45 *               eigenvectors of a complex Hermitian matrix in packed

  46 *               storage.

  47 *

  48 *               ZHBEVD computes all eigenvalues and, optionally,

  49 *               eigenvectors of a complex Hermitian band matrix,

  50 *               using a divide-and-conquer algorithm.

  51 *

  52 *               ZHBEVX computes selected eigenvalues and, optionally,

  53 *               eigenvectors of a complex Hermitian band matrix.

  54 *

  55 *               ZHEEV computes all eigenvalues and, optionally,

  56 *               eigenvectors of a complex Hermitian matrix.

  57 *

  58 *               ZHPEV computes all eigenvalues and, optionally,

  59 *               eigenvectors of a complex Hermitian matrix in packed

  60 *               storage.

  61 *

  62 *               ZHBEV computes all eigenvalues and, optionally,

  63 *               eigenvectors of a complex Hermitian band matrix.

  64 *

  65 *       When ZDRVST is called, a number of matrix "sizes" ("n's") and a

  66 *       number of matrix "types" are specified.  For each size ("n")

  67 *       and each type of matrix, one matrix will be generated and used

  68 *       to test the appropriate drivers.  For each matrix and each

  69 *       driver routine called, the following tests will be performed:

  70 *

  71 *       (1)     | A - Z D Z' | / ( |A| n ulp )

  72 *

  73 *       (2)     | I - Z Z' | / ( n ulp )

  74 *

  75 *       (3)     | D1 - D2 | / ( |D1| ulp )

  76 *

  77 *       where Z is the matrix of eigenvectors returned when the

  78 *       eigenvector option is given and D1 and D2 are the eigenvalues

  79 *       returned with and without the eigenvector option.

  80 *

  81 *       The "sizes" are specified by an array NN(1:NSIZES); the value of

  82 *       each element NN(j) specifies one size.

  83 *       The "types" are specified by a logical array DOTYPE( 1:NTYPES );

  84 *       if DOTYPE(j) is .TRUE., then matrix type "j" will be generated.

  85 *       Currently, the list of possible types is:

  86 *

  87 *       (1)  The zero matrix.

  88 *       (2)  The identity matrix.

  89 *

  90 *       (3)  A diagonal matrix with evenly spaced entries

  91 *            1, ..., ULP  and random signs.

  92 *            (ULP = (first number larger than 1) - 1 )

  93 *       (4)  A diagonal matrix with geometrically spaced entries

  94 *            1, ..., ULP  and random signs.

  95 *       (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP

  96 *            and random signs.

  97 *

  98 *       (6)  Same as (4), but multiplied by SQRT( overflow threshold )

  99 *       (7)  Same as (4), but multiplied by SQRT( underflow threshold )

 100 *

 101 *       (8)  A matrix of the form  U* D U, where U is unitary and

 102 *            D has evenly spaced entries 1, ..., ULP with random signs

 103 *            on the diagonal.

 104 *

 105 *       (9)  A matrix of the form  U* D U, where U is unitary and

 106 *            D has geometrically spaced entries 1, ..., ULP with random

 107 *            signs on the diagonal.

 108 *

 109 *       (10) A matrix of the form  U* D U, where U is unitary and

 110 *            D has "clustered" entries 1, ULP,..., ULP with random

 111 *            signs on the diagonal.

 112 *

 113 *       (11) Same as (8), but multiplied by SQRT( overflow threshold )

 114 *       (12) Same as (8), but multiplied by SQRT( underflow threshold )

 115 *

 116 *       (13) Symmetric matrix with random entries chosen from (-1,1).

 117 *       (14) Same as (13), but multiplied by SQRT( overflow threshold )

 118 *       (15) Same as (13), but multiplied by SQRT( underflow threshold )

 119 *       (16) A band matrix with half bandwidth randomly chosen between

 120 *            0 and N-1, with evenly spaced eigenvalues 1, ..., ULP

 121 *            with random signs.

 122 *       (17) Same as (16), but multiplied by SQRT( overflow threshold )

 123 *       (18) Same as (16), but multiplied by SQRT( underflow threshold )

 124 *

 125 *  Arguments

 126 *  =========

 127 *

 128 *  NSIZES  INTEGER

 129 *          The number of sizes of matrices to use.  If it is zero,

 130 *          ZDRVST does nothing.  It must be at least zero.

 131 *          Not modified.

 132 *

 133 *  NN      INTEGER array, dimension (NSIZES)

 134 *          An array containing the sizes to be used for the matrices.

 135 *          Zero values will be skipped.  The values must be at least

 136 *          zero.

 137 *          Not modified.

 138 *

 139 *  NTYPES  INTEGER

 140 *          The number of elements in DOTYPE.   If it is zero, ZDRVST

 141 *          does nothing.  It must be at least zero.  If it is MAXTYP+1

 142 *          and NSIZES is 1, then an additional type, MAXTYP+1 is

 143 *          defined, which is to use whatever matrix is in A.  This

 144 *          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and

 145 *          DOTYPE(MAXTYP+1) is .TRUE. .

 146 *          Not modified.

 147 *

 148 *  DOTYPE  LOGICAL array, dimension (NTYPES)

 149 *          If DOTYPE(j) is .TRUE., then for each size in NN a

 150 *          matrix of that size and of type j will be generated.

 151 *          If NTYPES is smaller than the maximum number of types

 152 *          defined (PARAMETER MAXTYP), then types NTYPES+1 through

 153 *          MAXTYP will not be generated.  If NTYPES is larger

 154 *          than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES)

 155 *          will be ignored.

 156 *          Not modified.

 157 *

 158 *  ISEED   INTEGER array, dimension (4)

 159 *          On entry ISEED specifies the seed of the random number

 160 *          generator. The array elements should be between 0 and 4095;

 161 *          if not they will be reduced mod 4096.  Also, ISEED(4) must

 162 *          be odd.  The random number generator uses a linear

 163 *          congruential sequence limited to small integers, and so

 164 *          should produce machine independent random numbers. The

 165 *          values of ISEED are changed on exit, and can be used in the

 166 *          next call to ZDRVST to continue the same random number

 167 *          sequence.

 168 *          Modified.

 169 *

 170 *  THRESH  DOUBLE PRECISION

 171 *          A test will count as "failed" if the "error", computed as

 172 *          described above, exceeds THRESH.  Note that the error

 173 *          is scaled to be O(1), so THRESH should be a reasonably

 174 *          small multiple of 1, e.g., 10 or 100.  In particular,

 175 *          it should not depend on the precision (single vs. double)

 176 *          or the size of the matrix.  It must be at least zero.

 177 *          Not modified.

 178 *

 179 *  NOUNIT  INTEGER

 180 *          The FORTRAN unit number for printing out error messages

 181 *          (e.g., if a routine returns IINFO not equal to 0.)

 182 *          Not modified.

 183 *

 184 *  A       COMPLEX*16 array, dimension (LDA , max(NN))

 185 *          Used to hold the matrix whose eigenvalues are to be

 186 *          computed.  On exit, A contains the last matrix actually

 187 *          used.

 188 *          Modified.

 189 *

 190 *  LDA     INTEGER

 191 *          The leading dimension of A.  It must be at

 192 *          least 1 and at least max( NN ).

 193 *          Not modified.

 194 *

 195 *  D1      DOUBLE PRECISION array, dimension (max(NN))

 196 *          The eigenvalues of A, as computed by ZSTEQR simlutaneously

 197 *          with Z.  On exit, the eigenvalues in D1 correspond with the

 198 *          matrix in A.

 199 *          Modified.

 200 *

 201 *  D2      DOUBLE PRECISION array, dimension (max(NN))

 202 *          The eigenvalues of A, as computed by ZSTEQR if Z is not

 203 *          computed.  On exit, the eigenvalues in D2 correspond with

 204 *          the matrix in A.

 205 *          Modified.

 206 *

 207 *  D3      DOUBLE PRECISION array, dimension (max(NN))

 208 *          The eigenvalues of A, as computed by DSTERF.  On exit, the

 209 *          eigenvalues in D3 correspond with the matrix in A.

 210 *          Modified.

 211 *

 212 *  WA1     DOUBLE PRECISION array, dimension

 213 *

 214 *  WA2     DOUBLE PRECISION array, dimension

 215 *

 216 *  WA3     DOUBLE PRECISION array, dimension

 217 *

 218 *  U       COMPLEX*16 array, dimension (LDU, max(NN))

 219 *          The unitary matrix computed by ZHETRD + ZUNGC3.

 220 *          Modified.

 221 *

 222 *  LDU     INTEGER

 223 *          The leading dimension of U, Z, and V.  It must be at

 224 *          least 1 and at least max( NN ).

 225 *          Not modified.

 226 *

 227 *  V       COMPLEX*16 array, dimension (LDU, max(NN))

 228 *          The Housholder vectors computed by ZHETRD in reducing A to

 229 *          tridiagonal form.

 230 *          Modified.

 231 *

 232 *  TAU     COMPLEX*16 array, dimension (max(NN))

 233 *          The Householder factors computed by ZHETRD in reducing A

 234 *          to tridiagonal form.

 235 *          Modified.

 236 *

 237 *  Z       COMPLEX*16 array, dimension (LDU, max(NN))

 238 *          The unitary matrix of eigenvectors computed by ZHEEVD,

 239 *          ZHEEVX, ZHPEVD, CHPEVX, ZHBEVD, and CHBEVX.

 240 *          Modified.

 241 *

 242 *  WORK  - COMPLEX*16 array of dimension ( LWORK )

 243 *           Workspace.

 244 *           Modified.

 245 *

 246 *  LWORK - INTEGER

 247 *           The number of entries in WORK.  This must be at least

 248 *           2*max( NN(j), 2 )**2.

 249 *           Not modified.

 250 *

 251 *  RWORK   DOUBLE PRECISION array, dimension (3*max(NN))

 252 *           Workspace.

 253 *           Modified.

 254 *

 255 *  LRWORK - INTEGER

 256 *           The number of entries in RWORK.

 257 *

 258 *  IWORK   INTEGER array, dimension (6*max(NN))

 259 *          Workspace.

 260 *          Modified.

 261 *

 262 *  LIWORK - INTEGER

 263 *           The number of entries in IWORK.

 264 *

 265 *  RESULT  DOUBLE PRECISION array, dimension (??)

 266 *          The values computed by the tests described above.

 267 *          The values are currently limited to 1/ulp, to avoid

 268 *          overflow.

 269 *          Modified.

 270 *

 271 *  INFO    INTEGER

 272 *          If 0, then everything ran OK.

 273 *           -1: NSIZES < 0

 274 *           -2: Some NN(j) < 0

 275 *           -3: NTYPES < 0

 276 *           -5: THRESH < 0

 277 *           -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).

 278 *          -16: LDU < 1 or LDU < NMAX.

 279 *          -21: LWORK too small.

 280 *          If  DLATMR, SLATMS, ZHETRD, DORGC3, ZSTEQR, DSTERF,

 281 *              or DORMC2 returns an error code, the

 282 *              absolute value of it is returned.

 283 *          Modified.

 284 *

 285 *-----------------------------------------------------------------------

 286 *

 287 *       Some Local Variables and Parameters:

 288 *       ---- ----- --------- --- ----------

 289 *       ZERO, ONE       Real 0 and 1.

 290 *       MAXTYP          The number of types defined.

 291 *       NTEST           The number of tests performed, or which can

 292 *                       be performed so far, for the current matrix.

 293 *       NTESTT          The total number of tests performed so far.

 294 *       NMAX            Largest value in NN.

 295 *       NMATS           The number of matrices generated so far.

 296 *       NERRS           The number of tests which have exceeded THRESH

 297 *                       so far (computed by DLAFTS).

 298 *       COND, IMODE     Values to be passed to the matrix generators.

 299 *       ANORM           Norm of A; passed to matrix generators.

 300 *

 301 *       OVFL, UNFL      Overflow and underflow thresholds.

 302 *       ULP, ULPINV     Finest relative precision and its inverse.

 303 *       RTOVFL, RTUNFL  Square roots of the previous 2 values.

 304 *               The following four arrays decode JTYPE:

 305 *       KTYPE(j)        The general type (1-10) for type "j".

 306 *       KMODE(j)        The MODE value to be passed to the matrix

 307 *                       generator for type "j".

 308 *       KMAGN(j)        The order of magnitude ( O(1),

 309 *                       O(overflow^(1/2) ), O(underflow^(1/2) )

 310 *

 311 *  =====================================================================

 312 *

 313 *

 314 *     .. Parameters ..

 315       DOUBLE PRECISION   ZERO, ONE, TWO, TEN

 316       PARAMETER          ( ZERO = 0.0D+0, ONE = 1.0D+0, TWO = 2.0D+0,

 317      $                   TEN = 10.0D+0 )

 318       DOUBLE PRECISION   HALF

 319       PARAMETER          ( HALF = ONE / TWO )

 320       COMPLEX*16         CZERO, CONE

 321       PARAMETER          ( CZERO = ( 0.0D+0, 0.0D+0 ),

 322      $                   CONE = ( 1.0D+0, 0.0D+0 ) )

 323       INTEGER            MAXTYP

 324       PARAMETER          ( MAXTYP = 18 )

 325 *     ..

 326 *     .. Local Scalars ..

 327       LOGICAL            BADNN

 328       CHARACTER          UPLO

 329       INTEGER            I, IDIAG, IHBW, IINFO, IL, IMODE, INDWRK, INDX,

 330      $                   IROW, ITEMP, ITYPE, IU, IUPLO, J, J1, J2, JCOL,

 331      $                   JSIZE, JTYPE, KD, LGN, LIWEDC, LRWEDC, LWEDC,

 332      $                   M, M2, M3, MTYPES, N, NERRS, NMATS, NMAX,

 333      $                   NTEST, NTESTT

 334       DOUBLE PRECISION   ABSTOL, ANINV, ANORM, COND, OVFL, RTOVFL,

 335      $                   RTUNFL, TEMP1, TEMP2, TEMP3, ULP, ULPINV, UNFL,

 336      $                   VL, VU

 337 *     ..

 338 *     .. Local Arrays ..

 339       INTEGER            IDUMMA( 1 ), IOLDSD( 4 ), ISEED2( 4 ),

 340      $                   ISEED3( 4 ), KMAGN( MAXTYP ), KMODE( MAXTYP ),

 341      $                   KTYPE( MAXTYP )

 342 *     ..

 343 *     .. External Functions ..

 344       DOUBLE PRECISION   DLAMCH, DLARND, DSXT1

 345       EXTERNAL           DLAMCH, DLARND, DSXT1

 346 *     ..

 347 *     .. External Subroutines ..

 348       EXTERNAL           ALASVM, DLABAD, DLAFTS, XERBLA, ZHBEV, ZHBEVD,

 349      $                   ZHBEVX, ZHEEV, ZHEEVD, ZHEEVR, ZHEEVX, ZHET21,

 350      $                   ZHET22, ZHPEV, ZHPEVD, ZHPEVX, ZLACPY, ZLASET,

 351      $                   ZLATMR, ZLATMS

 352 *     ..

 353 *     .. Intrinsic Functions ..

 354       INTRINSIC          ABS, DBLE, INT, LOG, MAX, MIN, SQRT

 355 *     ..

 356 *     .. Data statements ..

 357       DATA               KTYPE / 1, 2, 5*4, 5*5, 3*8, 3*9 /

 358       DATA               KMAGN / 2*1, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 1,

 359      $                   2, 3, 1, 2, 3 /

 360       DATA               KMODE / 2*0, 4, 3, 1, 4, 4, 4, 3, 1, 4, 4, 0,

 361      $                   0, 0, 4, 4, 4 /

 362 *     ..

 363 *     .. Executable Statements ..

 364 *

 365 *     1)      Check for errors

 366 *

 367       NTESTT = 0

 368       INFO = 0

 369 *

 370       BADNN = .FALSE.

 371       NMAX = 1

 372       DO 10 J = 1, NSIZES

 373          NMAX = MAX( NMAX, NN( J ) )

 374          IF( NN( J ).LT.0 )

 375      $      BADNN = .TRUE.

 376    10 CONTINUE

 377 *

 378 *     Check for errors

 379 *

 380       IF( NSIZES.LT.0 ) THEN

 381          INFO = -1

 382       ELSE IF( BADNN ) THEN

 383          INFO = -2

 384       ELSE IF( NTYPES.LT.0 ) THEN

 385          INFO = -3

 386       ELSE IF( LDA.LT.NMAX ) THEN

 387          INFO = -9

 388       ELSE IF( LDU.LT.NMAX ) THEN

 389          INFO = -16

 390       ELSE IF( 2*MAX( 2, NMAX )**2.GT.LWORK ) THEN

 391          INFO = -22

 392       END IF

 393 *

 394       IF( INFO.NE.0 ) THEN

 395          CALL XERBLA( 'ZDRVST', -INFO )

 396          RETURN

 397       END IF

 398 *

 399 *     Quick return if nothing to do

 400 *

 401       IF( NSIZES.EQ.0 .OR. NTYPES.EQ.0 )

 402      $   RETURN

 403 *

 404 *     More Important constants

 405 *

 406       UNFL = DLAMCH( 'Safe minimum' )

 407       OVFL = DLAMCH( 'Overflow' )

 408       CALL DLABAD( UNFL, OVFL )

 409       ULP = DLAMCH( 'Epsilon' )*DLAMCH( 'Base' )

 410       ULPINV = ONE / ULP

 411       RTUNFL = SQRT( UNFL )

 412       RTOVFL = SQRT( OVFL )

 413 *

 414 *     Loop over sizes, types

 415 *

 416       DO 20 I = 1, 4

 417          ISEED2( I ) = ISEED( I )

 418          ISEED3( I ) = ISEED( I )

 419    20 CONTINUE

 420 *

 421       NERRS = 0

 422       NMATS = 0

 423 *

 424       DO 1220 JSIZE = 1, NSIZES

 425          N = NN( JSIZE )

 426          IF( N.GT.0 ) THEN

 427             LGN = INT( LOG( DBLE( N ) ) / LOG( TWO ) )

 428             IF( 2**LGN.LT.N )

 429      $         LGN = LGN + 1

 430             IF( 2**LGN.LT.N )

 431      $         LGN = LGN + 1

 432             LWEDC = MAX( 2*N+N*N, 2*N*N )

 433             LRWEDC = 1 + 4*N + 2*N*LGN + 3*N**2

 434             LIWEDC = 3 + 5*N

 435          ELSE

 436             LWEDC = 2

 437             LRWEDC = 8

 438             LIWEDC = 8

 439          END IF

 440          ANINV = ONE / DBLE( MAX( 1, N ) )

 441 *

 442          IF( NSIZES.NE.1 ) THEN

 443             MTYPES = MIN( MAXTYP, NTYPES )

 444          ELSE

 445             MTYPES = MIN( MAXTYP+1, NTYPES )

 446          END IF

 447 *

 448          DO 1210 JTYPE = 1, MTYPES

 449             IF( .NOT.DOTYPE( JTYPE ) )

 450      $         GO TO 1210

 451             NMATS = NMATS + 1

 452             NTEST = 0

 453 *

 454             DO 30 J = 1, 4

 455                IOLDSD( J ) = ISEED( J )

 456    30       CONTINUE

 457 *

 458 *           2)      Compute "A"

 459 *

 460 *                   Control parameters:

 461 *

 462 *               KMAGN  KMODE        KTYPE

 463 *           =1  O(1)   clustered 1  zero

 464 *           =2  large  clustered 2  identity

 465 *           =3  small  exponential  (none)

 466 *           =4         arithmetic   diagonal, (w/ eigenvalues)

 467 *           =5         random log   Hermitian, w/ eigenvalues

 468 *           =6         random       (none)

 469 *           =7                      random diagonal

 470 *           =8                      random Hermitian

 471 *           =9                      band Hermitian, w/ eigenvalues

 472 *

 473             IF( MTYPES.GT.MAXTYP )

 474      $         GO TO 110

 475 *

 476             ITYPE = KTYPE( JTYPE )

 477             IMODE = KMODE( JTYPE )

 478 *

 479 *           Compute norm

 480 *

 481             GO TO ( 40, 50, 60 )KMAGN( JTYPE )

 482 *

 483    40       CONTINUE

 484             ANORM = ONE

 485             GO TO 70

 486 *

 487    50       CONTINUE

 488             ANORM = ( RTOVFL*ULP )*ANINV

 489             GO TO 70

 490 *

 491    60       CONTINUE

 492             ANORM = RTUNFL*N*ULPINV

 493             GO TO 70

 494 *

 495    70       CONTINUE

 496 *

 497             CALL ZLASET( 'Full', LDA, N, CZERO, CZERO, A, LDA )

 498             IINFO = 0

 499             COND = ULPINV

 500 *

 501 *           Special Matrices -- Identity & Jordan block

 502 *

 503 *                   Zero

 504 *

 505             IF( ITYPE.EQ.1 ) THEN

 506                IINFO = 0

 507 *

 508             ELSE IF( ITYPE.EQ.2 ) THEN

 509 *

 510 *              Identity

 511 *

 512                DO 80 JCOL = 1, N

 513                   A( JCOL, JCOL ) = ANORM

 514    80          CONTINUE

 515 *

 516             ELSE IF( ITYPE.EQ.4 ) THEN

 517 *

 518 *              Diagonal Matrix, [Eigen]values Specified

 519 *

 520                CALL ZLATMS( N, N, 'S', ISEED, 'H', RWORK, IMODE, COND,

 521      $                      ANORM, 0, 0, 'N', A, LDA, WORK, IINFO )

 522 *

 523             ELSE IF( ITYPE.EQ.5 ) THEN

 524 *

 525 *              Hermitian, eigenvalues specified

 526 *

 527                CALL ZLATMS( N, N, 'S', ISEED, 'H', RWORK, IMODE, COND,

 528      $                      ANORM, N, N, 'N', A, LDA, WORK, IINFO )

 529 *

 530             ELSE IF( ITYPE.EQ.7 ) THEN

 531 *

 532 *              Diagonal, random eigenvalues

 533 *

 534                CALL ZLATMR( N, N, 'S', ISEED, 'H', WORK, 6, ONE, CONE,

 535      $                      'T', 'N', WORK( N+1 ), 1, ONE,

 536      $                      WORK( 2*N+1 ), 1, ONE, 'N', IDUMMA, 0, 0,

 537      $                      ZERO, ANORM, 'NO', A, LDA, IWORK, IINFO )

 538 *

 539             ELSE IF( ITYPE.EQ.8 ) THEN

 540 *

 541 *              Hermitian, random eigenvalues

 542 *

 543                CALL ZLATMR( N, N, 'S', ISEED, 'H', WORK, 6, ONE, CONE,

 544      $                      'T', 'N', WORK( N+1 ), 1, ONE,

 545      $                      WORK( 2*N+1 ), 1, ONE, 'N', IDUMMA, N, N,

 546      $                      ZERO, ANORM, 'NO', A, LDA, IWORK, IINFO )

 547 *

 548             ELSE IF( ITYPE.EQ.9 ) THEN

 549 *

 550 *              Hermitian banded, eigenvalues specified

 551 *

 552                IHBW = INT( ( N-1 )*DLARND( 1, ISEED3 ) )

 553                CALL ZLATMS( N, N, 'S', ISEED, 'H', RWORK, IMODE, COND,

 554      $                      ANORM, IHBW, IHBW, 'Z', U, LDU, WORK,

 555      $                      IINFO )

 556 *

 557 *              Store as dense matrix for most routines.

 558 *

 559                CALL ZLASET( 'Full', LDA, N, CZERO, CZERO, A, LDA )

 560                DO 100 IDIAG = -IHBW, IHBW

 561                   IROW = IHBW - IDIAG + 1

 562                   J1 = MAX( 1, IDIAG+1 )

 563                   J2 = MIN( N, N+IDIAG )

 564                   DO 90 J = J1, J2

 565                      I = J - IDIAG

 566                      A( I, J ) = U( IROW, J )

 567    90             CONTINUE

 568   100          CONTINUE

 569             ELSE

 570                IINFO = 1

 571             END IF

 572 *

 573             IF( IINFO.NE.0 ) THEN

 574                WRITE( NOUNIT, FMT = 9999 )'Generator', IINFO, N, JTYPE,

 575      $            IOLDSD

 576                INFO = ABS( IINFO )

 577                RETURN

 578             END IF

 579 *

 580   110       CONTINUE

 581 *

 582             ABSTOL = UNFL + UNFL

 583             IF( N.LE.1 ) THEN

 584                IL = 1

 585                IU = N

 586             ELSE

 587                IL = 1 + INT( ( N-1 )*DLARND( 1, ISEED2 ) )

 588                IU = 1 + INT( ( N-1 )*DLARND( 1, ISEED2 ) )

 589                IF( IL.GT.IU ) THEN

 590                   ITEMP = IL

 591                   IL = IU

 592                   IU = ITEMP

 593                END IF

 594             END IF

 595 *

 596 *           Perform tests storing upper or lower triangular

 597 *           part of matrix.

 598 *

 599             DO 1200 IUPLO = 0, 1

 600                IF( IUPLO.EQ.0 ) THEN

 601                   UPLO = 'L'

 602                ELSE

 603                   UPLO = 'U'

 604                END IF

 605 *

 606 *              Call ZHEEVD and CHEEVX.

 607 *

 608                CALL ZLACPY( ' ', N, N, A, LDA, V, LDU )

 609 *

 610                NTEST = NTEST + 1

 611                CALL ZHEEVD( 'V', UPLO, N, A, LDU, D1, WORK, LWEDC,

 612      $                      RWORK, LRWEDC, IWORK, LIWEDC, IINFO )

 613                IF( IINFO.NE.0 ) THEN

 614                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVD(V,' // UPLO //

 615      $               ')', IINFO, N, JTYPE, IOLDSD

 616                   INFO = ABS( IINFO )

 617                   IF( IINFO.LT.0 ) THEN

 618                      RETURN

 619                   ELSE

 620                      RESULT( NTEST ) = ULPINV

 621                      RESULT( NTEST+1 ) = ULPINV

 622                      RESULT( NTEST+2 ) = ULPINV

 623                      GO TO 130

 624                   END IF

 625                END IF

 626 *

 627 *              Do tests 1 and 2.

 628 *

 629                CALL ZHET21( 1, UPLO, N, 0, V, LDU, D1, D2, A, LDU, Z,

 630      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

 631 *

 632                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 633 *

 634                NTEST = NTEST + 2

 635                CALL ZHEEVD( 'N', UPLO, N, A, LDU, D3, WORK, LWEDC,

 636      $                      RWORK, LRWEDC, IWORK, LIWEDC, IINFO )

 637                IF( IINFO.NE.0 ) THEN

 638                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVD(N,' // UPLO //

 639      $               ')', IINFO, N, JTYPE, IOLDSD

 640                   INFO = ABS( IINFO )

 641                   IF( IINFO.LT.0 ) THEN

 642                      RETURN

 643                   ELSE

 644                      RESULT( NTEST ) = ULPINV

 645                      GO TO 130

 646                   END IF

 647                END IF

 648 *

 649 *              Do test 3.

 650 *

 651                TEMP1 = ZERO

 652                TEMP2 = ZERO

 653                DO 120 J = 1, N

 654                   TEMP1 = MAX( TEMP1, ABS( D1( J ) ), ABS( D3( J ) ) )

 655                   TEMP2 = MAX( TEMP2, ABS( D1( J )-D3( J ) ) )

 656   120          CONTINUE

 657                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

 658      $                           ULP*MAX( TEMP1, TEMP2 ) )

 659 *

 660   130          CONTINUE

 661                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 662 *

 663                NTEST = NTEST + 1

 664 *

 665                IF( N.GT.0 ) THEN

 666                   TEMP3 = MAX( ABS( D1( 1 ) ), ABS( D1( N ) ) )

 667                   IF( IL.NE.1 ) THEN

 668                      VL = D1( IL ) - MAX( HALF*( D1( IL )-D1( IL-1 ) ),

 669      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 670                   ELSE IF( N.GT.0 ) THEN

 671                      VL = D1( 1 ) - MAX( HALF*( D1( N )-D1( 1 ) ),

 672      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 673                   END IF

 674                   IF( IU.NE.N ) THEN

 675                      VU = D1( IU ) + MAX( HALF*( D1( IU+1 )-D1( IU ) ),

 676      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 677                   ELSE IF( N.GT.0 ) THEN

 678                      VU = D1( N ) + MAX( HALF*( D1( N )-D1( 1 ) ),

 679      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 680                   END IF

 681                ELSE

 682                   TEMP3 = ZERO

 683                   VL = ZERO

 684                   VU = ONE

 685                END IF

 686 *

 687                CALL ZHEEVX( 'V', 'A', UPLO, N, A, LDU, VL, VU, IL, IU,

 688      $                      ABSTOL, M, WA1, Z, LDU, WORK, LWORK, RWORK,

 689      $                      IWORK, IWORK( 5*N+1 ), IINFO )

 690                IF( IINFO.NE.0 ) THEN

 691                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVX(V,A,' // UPLO //

 692      $               ')', IINFO, N, JTYPE, IOLDSD

 693                   INFO = ABS( IINFO )

 694                   IF( IINFO.LT.0 ) THEN

 695                      RETURN

 696                   ELSE

 697                      RESULT( NTEST ) = ULPINV

 698                      RESULT( NTEST+1 ) = ULPINV

 699                      RESULT( NTEST+2 ) = ULPINV

 700                      GO TO 150

 701                   END IF

 702                END IF

 703 *

 704 *              Do tests 4 and 5.

 705 *

 706                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 707 *

 708                CALL ZHET21( 1, UPLO, N, 0, A, LDU, WA1, D2, Z, LDU, V,

 709      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

 710 *

 711                NTEST = NTEST + 2

 712                CALL ZHEEVX( 'N', 'A', UPLO, N, A, LDU, VL, VU, IL, IU,

 713      $                      ABSTOL, M2, WA2, Z, LDU, WORK, LWORK, RWORK,

 714      $                      IWORK, IWORK( 5*N+1 ), IINFO )

 715                IF( IINFO.NE.0 ) THEN

 716                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVX(N,A,' // UPLO //

 717      $               ')', IINFO, N, JTYPE, IOLDSD

 718                   INFO = ABS( IINFO )

 719                   IF( IINFO.LT.0 ) THEN

 720                      RETURN

 721                   ELSE

 722                      RESULT( NTEST ) = ULPINV

 723                      GO TO 150

 724                   END IF

 725                END IF

 726 *

 727 *              Do test 6.

 728 *

 729                TEMP1 = ZERO

 730                TEMP2 = ZERO

 731                DO 140 J = 1, N

 732                   TEMP1 = MAX( TEMP1, ABS( WA1( J ) ), ABS( WA2( J ) ) )

 733                   TEMP2 = MAX( TEMP2, ABS( WA1( J )-WA2( J ) ) )

 734   140          CONTINUE

 735                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

 736      $                           ULP*MAX( TEMP1, TEMP2 ) )

 737 *

 738   150          CONTINUE

 739                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 740 *

 741                NTEST = NTEST + 1

 742 *

 743                CALL ZHEEVX( 'V', 'I', UPLO, N, A, LDU, VL, VU, IL, IU,

 744      $                      ABSTOL, M2, WA2, Z, LDU, WORK, LWORK, RWORK,

 745      $                      IWORK, IWORK( 5*N+1 ), IINFO )

 746                IF( IINFO.NE.0 ) THEN

 747                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVX(V,I,' // UPLO //

 748      $               ')', IINFO, N, JTYPE, IOLDSD

 749                   INFO = ABS( IINFO )

 750                   IF( IINFO.LT.0 ) THEN

 751                      RETURN

 752                   ELSE

 753                      RESULT( NTEST ) = ULPINV

 754                      GO TO 160

 755                   END IF

 756                END IF

 757 *

 758 *              Do tests 7 and 8.

 759 *

 760                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 761 *

 762                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

 763      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

 764 *

 765                NTEST = NTEST + 2

 766 *

 767                CALL ZHEEVX( 'N', 'I', UPLO, N, A, LDU, VL, VU, IL, IU,

 768      $                      ABSTOL, M3, WA3, Z, LDU, WORK, LWORK, RWORK,

 769      $                      IWORK, IWORK( 5*N+1 ), IINFO )

 770                IF( IINFO.NE.0 ) THEN

 771                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVX(N,I,' // UPLO //

 772      $               ')', IINFO, N, JTYPE, IOLDSD

 773                   INFO = ABS( IINFO )

 774                   IF( IINFO.LT.0 ) THEN

 775                      RETURN

 776                   ELSE

 777                      RESULT( NTEST ) = ULPINV

 778                      GO TO 160

 779                   END IF

 780                END IF

 781 *

 782 *              Do test 9.

 783 *

 784                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

 785                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

 786                IF( N.GT.0 ) THEN

 787                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

 788                ELSE

 789                   TEMP3 = ZERO

 790                END IF

 791                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

 792      $                           MAX( UNFL, TEMP3*ULP )

 793 *

 794   160          CONTINUE

 795                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 796 *

 797                NTEST = NTEST + 1

 798 *

 799                CALL ZHEEVX( 'V', 'V', UPLO, N, A, LDU, VL, VU, IL, IU,

 800      $                      ABSTOL, M2, WA2, Z, LDU, WORK, LWORK, RWORK,

 801      $                      IWORK, IWORK( 5*N+1 ), IINFO )

 802                IF( IINFO.NE.0 ) THEN

 803                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVX(V,V,' // UPLO //

 804      $               ')', IINFO, N, JTYPE, IOLDSD

 805                   INFO = ABS( IINFO )

 806                   IF( IINFO.LT.0 ) THEN

 807                      RETURN

 808                   ELSE

 809                      RESULT( NTEST ) = ULPINV

 810                      GO TO 170

 811                   END IF

 812                END IF

 813 *

 814 *              Do tests 10 and 11.

 815 *

 816                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 817 *

 818                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

 819      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

 820 *

 821                NTEST = NTEST + 2

 822 *

 823                CALL ZHEEVX( 'N', 'V', UPLO, N, A, LDU, VL, VU, IL, IU,

 824      $                      ABSTOL, M3, WA3, Z, LDU, WORK, LWORK, RWORK,

 825      $                      IWORK, IWORK( 5*N+1 ), IINFO )

 826                IF( IINFO.NE.0 ) THEN

 827                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVX(N,V,' // UPLO //

 828      $               ')', IINFO, N, JTYPE, IOLDSD

 829                   INFO = ABS( IINFO )

 830                   IF( IINFO.LT.0 ) THEN

 831                      RETURN

 832                   ELSE

 833                      RESULT( NTEST ) = ULPINV

 834                      GO TO 170

 835                   END IF

 836                END IF

 837 *

 838                IF( M3.EQ.0 .AND. N.GT.0 ) THEN

 839                   RESULT( NTEST ) = ULPINV

 840                   GO TO 170

 841                END IF

 842 *

 843 *              Do test 12.

 844 *

 845                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

 846                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

 847                IF( N.GT.0 ) THEN

 848                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

 849                ELSE

 850                   TEMP3 = ZERO

 851                END IF

 852                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

 853      $                           MAX( UNFL, TEMP3*ULP )

 854 *

 855   170          CONTINUE

 856 *

 857 *              Call ZHPEVD and CHPEVX.

 858 *

 859                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

 860 *

 861 *              Load array WORK with the upper or lower triangular

 862 *              part of the matrix in packed form.

 863 *

 864                IF( IUPLO.EQ.1 ) THEN

 865                   INDX = 1

 866                   DO 190 J = 1, N

 867                      DO 180 I = 1, J

 868                         WORK( INDX ) = A( I, J )

 869                         INDX = INDX + 1

 870   180                CONTINUE

 871   190             CONTINUE

 872                ELSE

 873                   INDX = 1

 874                   DO 210 J = 1, N

 875                      DO 200 I = J, N

 876                         WORK( INDX ) = A( I, J )

 877                         INDX = INDX + 1

 878   200                CONTINUE

 879   210             CONTINUE

 880                END IF

 881 *

 882                NTEST = NTEST + 1

 883                INDWRK = N*( N+1 ) / 2 + 1

 884                CALL ZHPEVD( 'V', UPLO, N, WORK, D1, Z, LDU,

 885      $                      WORK( INDWRK ), LWEDC, RWORK, LRWEDC, IWORK,

 886      $                      LIWEDC, IINFO )

 887                IF( IINFO.NE.0 ) THEN

 888                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVD(V,' // UPLO //

 889      $               ')', IINFO, N, JTYPE, IOLDSD

 890                   INFO = ABS( IINFO )

 891                   IF( IINFO.LT.0 ) THEN

 892                      RETURN

 893                   ELSE

 894                      RESULT( NTEST ) = ULPINV

 895                      RESULT( NTEST+1 ) = ULPINV

 896                      RESULT( NTEST+2 ) = ULPINV

 897                      GO TO 270

 898                   END IF

 899                END IF

 900 *

 901 *              Do tests 13 and 14.

 902 *

 903                CALL ZHET21( 1, UPLO, N, 0, A, LDA, D1, D2, Z, LDU, V,

 904      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

 905 *

 906                IF( IUPLO.EQ.1 ) THEN

 907                   INDX = 1

 908                   DO 230 J = 1, N

 909                      DO 220 I = 1, J

 910                         WORK( INDX ) = A( I, J )

 911                         INDX = INDX + 1

 912   220                CONTINUE

 913   230             CONTINUE

 914                ELSE

 915                   INDX = 1

 916                   DO 250 J = 1, N

 917                      DO 240 I = J, N

 918                         WORK( INDX ) = A( I, J )

 919                         INDX = INDX + 1

 920   240                CONTINUE

 921   250             CONTINUE

 922                END IF

 923 *

 924                NTEST = NTEST + 2

 925                INDWRK = N*( N+1 ) / 2 + 1

 926                CALL ZHPEVD( 'N', UPLO, N, WORK, D3, Z, LDU,

 927      $                      WORK( INDWRK ), LWEDC, RWORK, LRWEDC, IWORK,

 928      $                      LIWEDC, IINFO )

 929                IF( IINFO.NE.0 ) THEN

 930                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVD(N,' // UPLO //

 931      $               ')', IINFO, N, JTYPE, IOLDSD

 932                   INFO = ABS( IINFO )

 933                   IF( IINFO.LT.0 ) THEN

 934                      RETURN

 935                   ELSE

 936                      RESULT( NTEST ) = ULPINV

 937                      GO TO 270

 938                   END IF

 939                END IF

 940 *

 941 *              Do test 15.

 942 *

 943                TEMP1 = ZERO

 944                TEMP2 = ZERO

 945                DO 260 J = 1, N

 946                   TEMP1 = MAX( TEMP1, ABS( D1( J ) ), ABS( D3( J ) ) )

 947                   TEMP2 = MAX( TEMP2, ABS( D1( J )-D3( J ) ) )

 948   260          CONTINUE

 949                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

 950      $                           ULP*MAX( TEMP1, TEMP2 ) )

 951 *

 952 *              Load array WORK with the upper or lower triangular part

 953 *              of the matrix in packed form.

 954 *

 955   270          CONTINUE

 956                IF( IUPLO.EQ.1 ) THEN

 957                   INDX = 1

 958                   DO 290 J = 1, N

 959                      DO 280 I = 1, J

 960                         WORK( INDX ) = A( I, J )

 961                         INDX = INDX + 1

 962   280                CONTINUE

 963   290             CONTINUE

 964                ELSE

 965                   INDX = 1

 966                   DO 310 J = 1, N

 967                      DO 300 I = J, N

 968                         WORK( INDX ) = A( I, J )

 969                         INDX = INDX + 1

 970   300                CONTINUE

 971   310             CONTINUE

 972                END IF

 973 *

 974                NTEST = NTEST + 1

 975 *

 976                IF( N.GT.0 ) THEN

 977                   TEMP3 = MAX( ABS( D1( 1 ) ), ABS( D1( N ) ) )

 978                   IF( IL.NE.1 ) THEN

 979                      VL = D1( IL ) - MAX( HALF*( D1( IL )-D1( IL-1 ) ),

 980      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 981                   ELSE IF( N.GT.0 ) THEN

 982                      VL = D1( 1 ) - MAX( HALF*( D1( N )-D1( 1 ) ),

 983      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 984                   END IF

 985                   IF( IU.NE.N ) THEN

 986                      VU = D1( IU ) + MAX( HALF*( D1( IU+1 )-D1( IU ) ),

 987      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 988                   ELSE IF( N.GT.0 ) THEN

 989                      VU = D1( N ) + MAX( HALF*( D1( N )-D1( 1 ) ),

 990      $                    TEN*ULP*TEMP3, TEN*RTUNFL )

 991                   END IF

 992                ELSE

 993                   TEMP3 = ZERO

 994                   VL = ZERO

 995                   VU = ONE

 996                END IF

 997 *

 998                CALL ZHPEVX( 'V', 'A', UPLO, N, WORK, VL, VU, IL, IU,

 999      $                      ABSTOL, M, WA1, Z, LDU, V, RWORK, IWORK,

1000      $                      IWORK( 5*N+1 ), IINFO )

1001                IF( IINFO.NE.0 ) THEN

1002                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVX(V,A,' // UPLO //

1003      $               ')', IINFO, N, JTYPE, IOLDSD

1004                   INFO = ABS( IINFO )

1005                   IF( IINFO.LT.0 ) THEN

1006                      RETURN

1007                   ELSE

1008                      RESULT( NTEST ) = ULPINV

1009                      RESULT( NTEST+1 ) = ULPINV

1010                      RESULT( NTEST+2 ) = ULPINV

1011                      GO TO 370

1012                   END IF

1013                END IF

1014 *

1015 *              Do tests 16 and 17.

1016 *

1017                CALL ZHET21( 1, UPLO, N, 0, A, LDU, WA1, D2, Z, LDU, V,

1018      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1019 *

1020                NTEST = NTEST + 2

1021 *

1022                IF( IUPLO.EQ.1 ) THEN

1023                   INDX = 1

1024                   DO 330 J = 1, N

1025                      DO 320 I = 1, J

1026                         WORK( INDX ) = A( I, J )

1027                         INDX = INDX + 1

1028   320                CONTINUE

1029   330             CONTINUE

1030                ELSE

1031                   INDX = 1

1032                   DO 350 J = 1, N

1033                      DO 340 I = J, N

1034                         WORK( INDX ) = A( I, J )

1035                         INDX = INDX + 1

1036   340                CONTINUE

1037   350             CONTINUE

1038                END IF

1039 *

1040                CALL ZHPEVX( 'N', 'A', UPLO, N, WORK, VL, VU, IL, IU,

1041      $                      ABSTOL, M2, WA2, Z, LDU, V, RWORK, IWORK,

1042      $                      IWORK( 5*N+1 ), IINFO )

1043                IF( IINFO.NE.0 ) THEN

1044                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVX(N,A,' // UPLO //

1045      $               ')', IINFO, N, JTYPE, IOLDSD

1046                   INFO = ABS( IINFO )

1047                   IF( IINFO.LT.0 ) THEN

1048                      RETURN

1049                   ELSE

1050                      RESULT( NTEST ) = ULPINV

1051                      GO TO 370

1052                   END IF

1053                END IF

1054 *

1055 *              Do test 18.

1056 *

1057                TEMP1 = ZERO

1058                TEMP2 = ZERO

1059                DO 360 J = 1, N

1060                   TEMP1 = MAX( TEMP1, ABS( WA1( J ) ), ABS( WA2( J ) ) )

1061                   TEMP2 = MAX( TEMP2, ABS( WA1( J )-WA2( J ) ) )

1062   360          CONTINUE

1063                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1064      $                           ULP*MAX( TEMP1, TEMP2 ) )

1065 *

1066   370          CONTINUE

1067                NTEST = NTEST + 1

1068                IF( IUPLO.EQ.1 ) THEN

1069                   INDX = 1

1070                   DO 390 J = 1, N

1071                      DO 380 I = 1, J

1072                         WORK( INDX ) = A( I, J )

1073                         INDX = INDX + 1

1074   380                CONTINUE

1075   390             CONTINUE

1076                ELSE

1077                   INDX = 1

1078                   DO 410 J = 1, N

1079                      DO 400 I = J, N

1080                         WORK( INDX ) = A( I, J )

1081                         INDX = INDX + 1

1082   400                CONTINUE

1083   410             CONTINUE

1084                END IF

1085 *

1086                CALL ZHPEVX( 'V', 'I', UPLO, N, WORK, VL, VU, IL, IU,

1087      $                      ABSTOL, M2, WA2, Z, LDU, V, RWORK, IWORK,

1088      $                      IWORK( 5*N+1 ), IINFO )

1089                IF( IINFO.NE.0 ) THEN

1090                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVX(V,I,' // UPLO //

1091      $               ')', IINFO, N, JTYPE, IOLDSD

1092                   INFO = ABS( IINFO )

1093                   IF( IINFO.LT.0 ) THEN

1094                      RETURN

1095                   ELSE

1096                      RESULT( NTEST ) = ULPINV

1097                      RESULT( NTEST+1 ) = ULPINV

1098                      RESULT( NTEST+2 ) = ULPINV

1099                      GO TO 460

1100                   END IF

1101                END IF

1102 *

1103 *              Do tests 19 and 20.

1104 *

1105                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

1106      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1107 *

1108                NTEST = NTEST + 2

1109 *

1110                IF( IUPLO.EQ.1 ) THEN

1111                   INDX = 1

1112                   DO 430 J = 1, N

1113                      DO 420 I = 1, J

1114                         WORK( INDX ) = A( I, J )

1115                         INDX = INDX + 1

1116   420                CONTINUE

1117   430             CONTINUE

1118                ELSE

1119                   INDX = 1

1120                   DO 450 J = 1, N

1121                      DO 440 I = J, N

1122                         WORK( INDX ) = A( I, J )

1123                         INDX = INDX + 1

1124   440                CONTINUE

1125   450             CONTINUE

1126                END IF

1127 *

1128                CALL ZHPEVX( 'N', 'I', UPLO, N, WORK, VL, VU, IL, IU,

1129      $                      ABSTOL, M3, WA3, Z, LDU, V, RWORK, IWORK,

1130      $                      IWORK( 5*N+1 ), IINFO )

1131                IF( IINFO.NE.0 ) THEN

1132                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVX(N,I,' // UPLO //

1133      $               ')', IINFO, N, JTYPE, IOLDSD

1134                   INFO = ABS( IINFO )

1135                   IF( IINFO.LT.0 ) THEN

1136                      RETURN

1137                   ELSE

1138                      RESULT( NTEST ) = ULPINV

1139                      GO TO 460

1140                   END IF

1141                END IF

1142 *

1143 *              Do test 21.

1144 *

1145                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

1146                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

1147                IF( N.GT.0 ) THEN

1148                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

1149                ELSE

1150                   TEMP3 = ZERO

1151                END IF

1152                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

1153      $                           MAX( UNFL, TEMP3*ULP )

1154 *

1155   460          CONTINUE

1156                NTEST = NTEST + 1

1157                IF( IUPLO.EQ.1 ) THEN

1158                   INDX = 1

1159                   DO 480 J = 1, N

1160                      DO 470 I = 1, J

1161                         WORK( INDX ) = A( I, J )

1162                         INDX = INDX + 1

1163   470                CONTINUE

1164   480             CONTINUE

1165                ELSE

1166                   INDX = 1

1167                   DO 500 J = 1, N

1168                      DO 490 I = J, N

1169                         WORK( INDX ) = A( I, J )

1170                         INDX = INDX + 1

1171   490                CONTINUE

1172   500             CONTINUE

1173                END IF

1174 *

1175                CALL ZHPEVX( 'V', 'V', UPLO, N, WORK, VL, VU, IL, IU,

1176      $                      ABSTOL, M2, WA2, Z, LDU, V, RWORK, IWORK,

1177      $                      IWORK( 5*N+1 ), IINFO )

1178                IF( IINFO.NE.0 ) THEN

1179                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVX(V,V,' // UPLO //

1180      $               ')', IINFO, N, JTYPE, IOLDSD

1181                   INFO = ABS( IINFO )

1182                   IF( IINFO.LT.0 ) THEN

1183                      RETURN

1184                   ELSE

1185                      RESULT( NTEST ) = ULPINV

1186                      RESULT( NTEST+1 ) = ULPINV

1187                      RESULT( NTEST+2 ) = ULPINV

1188                      GO TO 550

1189                   END IF

1190                END IF

1191 *

1192 *              Do tests 22 and 23.

1193 *

1194                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

1195      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1196 *

1197                NTEST = NTEST + 2

1198 *

1199                IF( IUPLO.EQ.1 ) THEN

1200                   INDX = 1

1201                   DO 520 J = 1, N

1202                      DO 510 I = 1, J

1203                         WORK( INDX ) = A( I, J )

1204                         INDX = INDX + 1

1205   510                CONTINUE

1206   520             CONTINUE

1207                ELSE

1208                   INDX = 1

1209                   DO 540 J = 1, N

1210                      DO 530 I = J, N

1211                         WORK( INDX ) = A( I, J )

1212                         INDX = INDX + 1

1213   530                CONTINUE

1214   540             CONTINUE

1215                END IF

1216 *

1217                CALL ZHPEVX( 'N', 'V', UPLO, N, WORK, VL, VU, IL, IU,

1218      $                      ABSTOL, M3, WA3, Z, LDU, V, RWORK, IWORK,

1219      $                      IWORK( 5*N+1 ), IINFO )

1220                IF( IINFO.NE.0 ) THEN

1221                   WRITE( NOUNIT, FMT = 9999 )'ZHPEVX(N,V,' // UPLO //

1222      $               ')', IINFO, N, JTYPE, IOLDSD

1223                   INFO = ABS( IINFO )

1224                   IF( IINFO.LT.0 ) THEN

1225                      RETURN

1226                   ELSE

1227                      RESULT( NTEST ) = ULPINV

1228                      GO TO 550

1229                   END IF

1230                END IF

1231 *

1232                IF( M3.EQ.0 .AND. N.GT.0 ) THEN

1233                   RESULT( NTEST ) = ULPINV

1234                   GO TO 550

1235                END IF

1236 *

1237 *              Do test 24.

1238 *

1239                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

1240                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

1241                IF( N.GT.0 ) THEN

1242                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

1243                ELSE

1244                   TEMP3 = ZERO

1245                END IF

1246                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

1247      $                           MAX( UNFL, TEMP3*ULP )

1248 *

1249   550          CONTINUE

1250 *

1251 *              Call ZHBEVD and CHBEVX.

1252 *

1253                IF( JTYPE.LE.7 ) THEN

1254                   KD = 0

1255                ELSE IF( JTYPE.GE.8 .AND. JTYPE.LE.15 ) THEN

1256                   KD = MAX( N-1, 0 )

1257                ELSE

1258                   KD = IHBW

1259                END IF

1260 *

1261 *              Load array V with the upper or lower triangular part

1262 *              of the matrix in band form.

1263 *

1264                IF( IUPLO.EQ.1 ) THEN

1265                   DO 570 J = 1, N

1266                      DO 560 I = MAX( 1, J-KD ), J

1267                         V( KD+1+I-J, J ) = A( I, J )

1268   560                CONTINUE

1269   570             CONTINUE

1270                ELSE

1271                   DO 590 J = 1, N

1272                      DO 580 I = J, MIN( N, J+KD )

1273                         V( 1+I-J, J ) = A( I, J )

1274   580                CONTINUE

1275   590             CONTINUE

1276                END IF

1277 *

1278                NTEST = NTEST + 1

1279                CALL ZHBEVD( 'V', UPLO, N, KD, V, LDU, D1, Z, LDU, WORK,

1280      $                      LWEDC, RWORK, LRWEDC, IWORK, LIWEDC, IINFO )

1281                IF( IINFO.NE.0 ) THEN

1282                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVD(V,' // UPLO //

1283      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1284                   INFO = ABS( IINFO )

1285                   IF( IINFO.LT.0 ) THEN

1286                      RETURN

1287                   ELSE

1288                      RESULT( NTEST ) = ULPINV

1289                      RESULT( NTEST+1 ) = ULPINV

1290                      RESULT( NTEST+2 ) = ULPINV

1291                      GO TO 650

1292                   END IF

1293                END IF

1294 *

1295 *              Do tests 25 and 26.

1296 *

1297                CALL ZHET21( 1, UPLO, N, 0, A, LDA, D1, D2, Z, LDU, V,

1298      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1299 *

1300                IF( IUPLO.EQ.1 ) THEN

1301                   DO 610 J = 1, N

1302                      DO 600 I = MAX( 1, J-KD ), J

1303                         V( KD+1+I-J, J ) = A( I, J )

1304   600                CONTINUE

1305   610             CONTINUE

1306                ELSE

1307                   DO 630 J = 1, N

1308                      DO 620 I = J, MIN( N, J+KD )

1309                         V( 1+I-J, J ) = A( I, J )

1310   620                CONTINUE

1311   630             CONTINUE

1312                END IF

1313 *

1314                NTEST = NTEST + 2

1315                CALL ZHBEVD( 'N', UPLO, N, KD, V, LDU, D3, Z, LDU, WORK,

1316      $                      LWEDC, RWORK, LRWEDC, IWORK, LIWEDC, IINFO )

1317                IF( IINFO.NE.0 ) THEN

1318                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVD(N,' // UPLO //

1319      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1320                   INFO = ABS( IINFO )

1321                   IF( IINFO.LT.0 ) THEN

1322                      RETURN

1323                   ELSE

1324                      RESULT( NTEST ) = ULPINV

1325                      GO TO 650

1326                   END IF

1327                END IF

1328 *

1329 *              Do test 27.

1330 *

1331                TEMP1 = ZERO

1332                TEMP2 = ZERO

1333                DO 640 J = 1, N

1334                   TEMP1 = MAX( TEMP1, ABS( D1( J ) ), ABS( D3( J ) ) )

1335                   TEMP2 = MAX( TEMP2, ABS( D1( J )-D3( J ) ) )

1336   640          CONTINUE

1337                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1338      $                           ULP*MAX( TEMP1, TEMP2 ) )

1339 *

1340 *              Load array V with the upper or lower triangular part

1341 *              of the matrix in band form.

1342 *

1343   650          CONTINUE

1344                IF( IUPLO.EQ.1 ) THEN

1345                   DO 670 J = 1, N

1346                      DO 660 I = MAX( 1, J-KD ), J

1347                         V( KD+1+I-J, J ) = A( I, J )

1348   660                CONTINUE

1349   670             CONTINUE

1350                ELSE

1351                   DO 690 J = 1, N

1352                      DO 680 I = J, MIN( N, J+KD )

1353                         V( 1+I-J, J ) = A( I, J )

1354   680                CONTINUE

1355   690             CONTINUE

1356                END IF

1357 *

1358                NTEST = NTEST + 1

1359                CALL ZHBEVX( 'V', 'A', UPLO, N, KD, V, LDU, U, LDU, VL,

1360      $                      VU, IL, IU, ABSTOL, M, WA1, Z, LDU, WORK,

1361      $                      RWORK, IWORK, IWORK( 5*N+1 ), IINFO )

1362                IF( IINFO.NE.0 ) THEN

1363                   WRITE( NOUNIT, FMT = 9999 )'ZHBEVX(V,A,' // UPLO //

1364      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1365                   INFO = ABS( IINFO )

1366                   IF( IINFO.LT.0 ) THEN

1367                      RETURN

1368                   ELSE

1369                      RESULT( NTEST ) = ULPINV

1370                      RESULT( NTEST+1 ) = ULPINV

1371                      RESULT( NTEST+2 ) = ULPINV

1372                      GO TO 750

1373                   END IF

1374                END IF

1375 *

1376 *              Do tests 28 and 29.

1377 *

1378                CALL ZHET21( 1, UPLO, N, 0, A, LDU, WA1, D2, Z, LDU, V,

1379      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1380 *

1381                NTEST = NTEST + 2

1382 *

1383                IF( IUPLO.EQ.1 ) THEN

1384                   DO 710 J = 1, N

1385                      DO 700 I = MAX( 1, J-KD ), J

1386                         V( KD+1+I-J, J ) = A( I, J )

1387   700                CONTINUE

1388   710             CONTINUE

1389                ELSE

1390                   DO 730 J = 1, N

1391                      DO 720 I = J, MIN( N, J+KD )

1392                         V( 1+I-J, J ) = A( I, J )

1393   720                CONTINUE

1394   730             CONTINUE

1395                END IF

1396 *

1397                CALL ZHBEVX( 'N', 'A', UPLO, N, KD, V, LDU, U, LDU, VL,

1398      $                      VU, IL, IU, ABSTOL, M2, WA2, Z, LDU, WORK,

1399      $                      RWORK, IWORK, IWORK( 5*N+1 ), IINFO )

1400                IF( IINFO.NE.0 ) THEN

1401                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVX(N,A,' // UPLO //

1402      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1403                   INFO = ABS( IINFO )

1404                   IF( IINFO.LT.0 ) THEN

1405                      RETURN

1406                   ELSE

1407                      RESULT( NTEST ) = ULPINV

1408                      GO TO 750

1409                   END IF

1410                END IF

1411 *

1412 *              Do test 30.

1413 *

1414                TEMP1 = ZERO

1415                TEMP2 = ZERO

1416                DO 740 J = 1, N

1417                   TEMP1 = MAX( TEMP1, ABS( WA1( J ) ), ABS( WA2( J ) ) )

1418                   TEMP2 = MAX( TEMP2, ABS( WA1( J )-WA2( J ) ) )

1419   740          CONTINUE

1420                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1421      $                           ULP*MAX( TEMP1, TEMP2 ) )

1422 *

1423 *              Load array V with the upper or lower triangular part

1424 *              of the matrix in band form.

1425 *

1426   750          CONTINUE

1427                NTEST = NTEST + 1

1428                IF( IUPLO.EQ.1 ) THEN

1429                   DO 770 J = 1, N

1430                      DO 760 I = MAX( 1, J-KD ), J

1431                         V( KD+1+I-J, J ) = A( I, J )

1432   760                CONTINUE

1433   770             CONTINUE

1434                ELSE

1435                   DO 790 J = 1, N

1436                      DO 780 I = J, MIN( N, J+KD )

1437                         V( 1+I-J, J ) = A( I, J )

1438   780                CONTINUE

1439   790             CONTINUE

1440                END IF

1441 *

1442                CALL ZHBEVX( 'V', 'I', UPLO, N, KD, V, LDU, U, LDU, VL,

1443      $                      VU, IL, IU, ABSTOL, M2, WA2, Z, LDU, WORK,

1444      $                      RWORK, IWORK, IWORK( 5*N+1 ), IINFO )

1445                IF( IINFO.NE.0 ) THEN

1446                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVX(V,I,' // UPLO //

1447      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1448                   INFO = ABS( IINFO )

1449                   IF( IINFO.LT.0 ) THEN

1450                      RETURN

1451                   ELSE

1452                      RESULT( NTEST ) = ULPINV

1453                      RESULT( NTEST+1 ) = ULPINV

1454                      RESULT( NTEST+2 ) = ULPINV

1455                      GO TO 840

1456                   END IF

1457                END IF

1458 *

1459 *              Do tests 31 and 32.

1460 *

1461                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

1462      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1463 *

1464                NTEST = NTEST + 2

1465 *

1466                IF( IUPLO.EQ.1 ) THEN

1467                   DO 810 J = 1, N

1468                      DO 800 I = MAX( 1, J-KD ), J

1469                         V( KD+1+I-J, J ) = A( I, J )

1470   800                CONTINUE

1471   810             CONTINUE

1472                ELSE

1473                   DO 830 J = 1, N

1474                      DO 820 I = J, MIN( N, J+KD )

1475                         V( 1+I-J, J ) = A( I, J )

1476   820                CONTINUE

1477   830             CONTINUE

1478                END IF

1479                CALL ZHBEVX( 'N', 'I', UPLO, N, KD, V, LDU, U, LDU, VL,

1480      $                      VU, IL, IU, ABSTOL, M3, WA3, Z, LDU, WORK,

1481      $                      RWORK, IWORK, IWORK( 5*N+1 ), IINFO )

1482                IF( IINFO.NE.0 ) THEN

1483                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVX(N,I,' // UPLO //

1484      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1485                   INFO = ABS( IINFO )

1486                   IF( IINFO.LT.0 ) THEN

1487                      RETURN

1488                   ELSE

1489                      RESULT( NTEST ) = ULPINV

1490                      GO TO 840

1491                   END IF

1492                END IF

1493 *

1494 *              Do test 33.

1495 *

1496                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

1497                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

1498                IF( N.GT.0 ) THEN

1499                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

1500                ELSE

1501                   TEMP3 = ZERO

1502                END IF

1503                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

1504      $                           MAX( UNFL, TEMP3*ULP )

1505 *

1506 *              Load array V with the upper or lower triangular part

1507 *              of the matrix in band form.

1508 *

1509   840          CONTINUE

1510                NTEST = NTEST + 1

1511                IF( IUPLO.EQ.1 ) THEN

1512                   DO 860 J = 1, N

1513                      DO 850 I = MAX( 1, J-KD ), J

1514                         V( KD+1+I-J, J ) = A( I, J )

1515   850                CONTINUE

1516   860             CONTINUE

1517                ELSE

1518                   DO 880 J = 1, N

1519                      DO 870 I = J, MIN( N, J+KD )

1520                         V( 1+I-J, J ) = A( I, J )

1521   870                CONTINUE

1522   880             CONTINUE

1523                END IF

1524                CALL ZHBEVX( 'V', 'V', UPLO, N, KD, V, LDU, U, LDU, VL,

1525      $                      VU, IL, IU, ABSTOL, M2, WA2, Z, LDU, WORK,

1526      $                      RWORK, IWORK, IWORK( 5*N+1 ), IINFO )

1527                IF( IINFO.NE.0 ) THEN

1528                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVX(V,V,' // UPLO //

1529      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1530                   INFO = ABS( IINFO )

1531                   IF( IINFO.LT.0 ) THEN

1532                      RETURN

1533                   ELSE

1534                      RESULT( NTEST ) = ULPINV

1535                      RESULT( NTEST+1 ) = ULPINV

1536                      RESULT( NTEST+2 ) = ULPINV

1537                      GO TO 930

1538                   END IF

1539                END IF

1540 *

1541 *              Do tests 34 and 35.

1542 *

1543                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

1544      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1545 *

1546                NTEST = NTEST + 2

1547 *

1548                IF( IUPLO.EQ.1 ) THEN

1549                   DO 900 J = 1, N

1550                      DO 890 I = MAX( 1, J-KD ), J

1551                         V( KD+1+I-J, J ) = A( I, J )

1552   890                CONTINUE

1553   900             CONTINUE

1554                ELSE

1555                   DO 920 J = 1, N

1556                      DO 910 I = J, MIN( N, J+KD )

1557                         V( 1+I-J, J ) = A( I, J )

1558   910                CONTINUE

1559   920             CONTINUE

1560                END IF

1561                CALL ZHBEVX( 'N', 'V', UPLO, N, KD, V, LDU, U, LDU, VL,

1562      $                      VU, IL, IU, ABSTOL, M3, WA3, Z, LDU, WORK,

1563      $                      RWORK, IWORK, IWORK( 5*N+1 ), IINFO )

1564                IF( IINFO.NE.0 ) THEN

1565                   WRITE( NOUNIT, FMT = 9998 )'ZHBEVX(N,V,' // UPLO //

1566      $               ')', IINFO, N, KD, JTYPE, IOLDSD

1567                   INFO = ABS( IINFO )

1568                   IF( IINFO.LT.0 ) THEN

1569                      RETURN

1570                   ELSE

1571                      RESULT( NTEST ) = ULPINV

1572                      GO TO 930

1573                   END IF

1574                END IF

1575 *

1576                IF( M3.EQ.0 .AND. N.GT.0 ) THEN

1577                   RESULT( NTEST ) = ULPINV

1578                   GO TO 930

1579                END IF

1580 *

1581 *              Do test 36.

1582 *

1583                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

1584                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

1585                IF( N.GT.0 ) THEN

1586                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

1587                ELSE

1588                   TEMP3 = ZERO

1589                END IF

1590                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

1591      $                           MAX( UNFL, TEMP3*ULP )

1592 *

1593   930          CONTINUE

1594 *

1595 *              Call ZHEEV

1596 *

1597                CALL ZLACPY( ' ', N, N, A, LDA, V, LDU )

1598 *

1599                NTEST = NTEST + 1

1600                CALL ZHEEV( 'V', UPLO, N, A, LDU, D1, WORK, LWORK, RWORK,

1601      $                     IINFO )

1602                IF( IINFO.NE.0 ) THEN

1603                   WRITE( NOUNIT, FMT = 9999 )'ZHEEV(V,' // UPLO // ')',

1604      $               IINFO, N, JTYPE, IOLDSD

1605                   INFO = ABS( IINFO )

1606                   IF( IINFO.LT.0 ) THEN

1607                      RETURN

1608                   ELSE

1609                      RESULT( NTEST ) = ULPINV

1610                      RESULT( NTEST+1 ) = ULPINV

1611                      RESULT( NTEST+2 ) = ULPINV

1612                      GO TO 950

1613                   END IF

1614                END IF

1615 *

1616 *              Do tests 37 and 38

1617 *

1618                CALL ZHET21( 1, UPLO, N, 0, V, LDU, D1, D2, A, LDU, Z,

1619      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1620 *

1621                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1622 *

1623                NTEST = NTEST + 2

1624                CALL ZHEEV( 'N', UPLO, N, A, LDU, D3, WORK, LWORK, RWORK,

1625      $                     IINFO )

1626                IF( IINFO.NE.0 ) THEN

1627                   WRITE( NOUNIT, FMT = 9999 )'ZHEEV(N,' // UPLO // ')',

1628      $               IINFO, N, JTYPE, IOLDSD

1629                   INFO = ABS( IINFO )

1630                   IF( IINFO.LT.0 ) THEN

1631                      RETURN

1632                   ELSE

1633                      RESULT( NTEST ) = ULPINV

1634                      GO TO 950

1635                   END IF

1636                END IF

1637 *

1638 *              Do test 39

1639 *

1640                TEMP1 = ZERO

1641                TEMP2 = ZERO

1642                DO 940 J = 1, N

1643                   TEMP1 = MAX( TEMP1, ABS( D1( J ) ), ABS( D3( J ) ) )

1644                   TEMP2 = MAX( TEMP2, ABS( D1( J )-D3( J ) ) )

1645   940          CONTINUE

1646                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1647      $                           ULP*MAX( TEMP1, TEMP2 ) )

1648 *

1649   950          CONTINUE

1650 *

1651                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1652 *

1653 *              Call ZHPEV

1654 *

1655 *              Load array WORK with the upper or lower triangular

1656 *              part of the matrix in packed form.

1657 *

1658                IF( IUPLO.EQ.1 ) THEN

1659                   INDX = 1

1660                   DO 970 J = 1, N

1661                      DO 960 I = 1, J

1662                         WORK( INDX ) = A( I, J )

1663                         INDX = INDX + 1

1664   960                CONTINUE

1665   970             CONTINUE

1666                ELSE

1667                   INDX = 1

1668                   DO 990 J = 1, N

1669                      DO 980 I = J, N

1670                         WORK( INDX ) = A( I, J )

1671                         INDX = INDX + 1

1672   980                CONTINUE

1673   990             CONTINUE

1674                END IF

1675 *

1676                NTEST = NTEST + 1

1677                INDWRK = N*( N+1 ) / 2 + 1

1678                CALL ZHPEV( 'V', UPLO, N, WORK, D1, Z, LDU,

1679      $                     WORK( INDWRK ), RWORK, IINFO )

1680                IF( IINFO.NE.0 ) THEN

1681                   WRITE( NOUNIT, FMT = 9999 )'ZHPEV(V,' // UPLO // ')',

1682      $               IINFO, N, JTYPE, IOLDSD

1683                   INFO = ABS( IINFO )

1684                   IF( IINFO.LT.0 ) THEN

1685                      RETURN

1686                   ELSE

1687                      RESULT( NTEST ) = ULPINV

1688                      RESULT( NTEST+1 ) = ULPINV

1689                      RESULT( NTEST+2 ) = ULPINV

1690                      GO TO 1050

1691                   END IF

1692                END IF

1693 *

1694 *              Do tests 40 and 41.

1695 *

1696                CALL ZHET21( 1, UPLO, N, 0, A, LDA, D1, D2, Z, LDU, V,

1697      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1698 *

1699                IF( IUPLO.EQ.1 ) THEN

1700                   INDX = 1

1701                   DO 1010 J = 1, N

1702                      DO 1000 I = 1, J

1703                         WORK( INDX ) = A( I, J )

1704                         INDX = INDX + 1

1705  1000                CONTINUE

1706  1010             CONTINUE

1707                ELSE

1708                   INDX = 1

1709                   DO 1030 J = 1, N

1710                      DO 1020 I = J, N

1711                         WORK( INDX ) = A( I, J )

1712                         INDX = INDX + 1

1713  1020                CONTINUE

1714  1030             CONTINUE

1715                END IF

1716 *

1717                NTEST = NTEST + 2

1718                INDWRK = N*( N+1 ) / 2 + 1

1719                CALL ZHPEV( 'N', UPLO, N, WORK, D3, Z, LDU,

1720      $                     WORK( INDWRK ), RWORK, IINFO )

1721                IF( IINFO.NE.0 ) THEN

1722                   WRITE( NOUNIT, FMT = 9999 )'ZHPEV(N,' // UPLO // ')',

1723      $               IINFO, N, JTYPE, IOLDSD

1724                   INFO = ABS( IINFO )

1725                   IF( IINFO.LT.0 ) THEN

1726                      RETURN

1727                   ELSE

1728                      RESULT( NTEST ) = ULPINV

1729                      GO TO 1050

1730                   END IF

1731                END IF

1732 *

1733 *              Do test 42

1734 *

1735                TEMP1 = ZERO

1736                TEMP2 = ZERO

1737                DO 1040 J = 1, N

1738                   TEMP1 = MAX( TEMP1, ABS( D1( J ) ), ABS( D3( J ) ) )

1739                   TEMP2 = MAX( TEMP2, ABS( D1( J )-D3( J ) ) )

1740  1040          CONTINUE

1741                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1742      $                           ULP*MAX( TEMP1, TEMP2 ) )

1743 *

1744  1050          CONTINUE

1745 *

1746 *              Call ZHBEV

1747 *

1748                IF( JTYPE.LE.7 ) THEN

1749                   KD = 0

1750                ELSE IF( JTYPE.GE.8 .AND. JTYPE.LE.15 ) THEN

1751                   KD = MAX( N-1, 0 )

1752                ELSE

1753                   KD = IHBW

1754                END IF

1755 *

1756 *              Load array V with the upper or lower triangular part

1757 *              of the matrix in band form.

1758 *

1759                IF( IUPLO.EQ.1 ) THEN

1760                   DO 1070 J = 1, N

1761                      DO 1060 I = MAX( 1, J-KD ), J

1762                         V( KD+1+I-J, J ) = A( I, J )

1763  1060                CONTINUE

1764  1070             CONTINUE

1765                ELSE

1766                   DO 1090 J = 1, N

1767                      DO 1080 I = J, MIN( N, J+KD )

1768                         V( 1+I-J, J ) = A( I, J )

1769  1080                CONTINUE

1770  1090             CONTINUE

1771                END IF

1772 *

1773                NTEST = NTEST + 1

1774                CALL ZHBEV( 'V', UPLO, N, KD, V, LDU, D1, Z, LDU, WORK,

1775      $                     RWORK, IINFO )

1776                IF( IINFO.NE.0 ) THEN

1777                   WRITE( NOUNIT, FMT = 9998 )'ZHBEV(V,' // UPLO // ')',

1778      $               IINFO, N, KD, JTYPE, IOLDSD

1779                   INFO = ABS( IINFO )

1780                   IF( IINFO.LT.0 ) THEN

1781                      RETURN

1782                   ELSE

1783                      RESULT( NTEST ) = ULPINV

1784                      RESULT( NTEST+1 ) = ULPINV

1785                      RESULT( NTEST+2 ) = ULPINV

1786                      GO TO 1140

1787                   END IF

1788                END IF

1789 *

1790 *              Do tests 43 and 44.

1791 *

1792                CALL ZHET21( 1, UPLO, N, 0, A, LDA, D1, D2, Z, LDU, V,

1793      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1794 *

1795                IF( IUPLO.EQ.1 ) THEN

1796                   DO 1110 J = 1, N

1797                      DO 1100 I = MAX( 1, J-KD ), J

1798                         V( KD+1+I-J, J ) = A( I, J )

1799  1100                CONTINUE

1800  1110             CONTINUE

1801                ELSE

1802                   DO 1130 J = 1, N

1803                      DO 1120 I = J, MIN( N, J+KD )

1804                         V( 1+I-J, J ) = A( I, J )

1805  1120                CONTINUE

1806  1130             CONTINUE

1807                END IF

1808 *

1809                NTEST = NTEST + 2

1810                CALL ZHBEV( 'N', UPLO, N, KD, V, LDU, D3, Z, LDU, WORK,

1811      $                     RWORK, IINFO )

1812                IF( IINFO.NE.0 ) THEN

1813                   WRITE( NOUNIT, FMT = 9998 )'ZHBEV(N,' // UPLO // ')',

1814      $               IINFO, N, KD, JTYPE, IOLDSD

1815                   INFO = ABS( IINFO )

1816                   IF( IINFO.LT.0 ) THEN

1817                      RETURN

1818                   ELSE

1819                      RESULT( NTEST ) = ULPINV

1820                      GO TO 1140

1821                   END IF

1822                END IF

1823 *

1824  1140          CONTINUE

1825 *

1826 *              Do test 45.

1827 *

1828                TEMP1 = ZERO

1829                TEMP2 = ZERO

1830                DO 1150 J = 1, N

1831                   TEMP1 = MAX( TEMP1, ABS( D1( J ) ), ABS( D3( J ) ) )

1832                   TEMP2 = MAX( TEMP2, ABS( D1( J )-D3( J ) ) )

1833  1150          CONTINUE

1834                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1835      $                           ULP*MAX( TEMP1, TEMP2 ) )

1836 *

1837                CALL ZLACPY( ' ', N, N, A, LDA, V, LDU )

1838                NTEST = NTEST + 1

1839                CALL ZHEEVR( 'V', 'A', UPLO, N, A, LDU, VL, VU, IL, IU,

1840      $                      ABSTOL, M, WA1, Z, LDU, IWORK, WORK, LWORK,

1841      $                      RWORK, LRWORK, IWORK( 2*N+1 ), LIWORK-2*N,

1842      $                      IINFO )

1843                IF( IINFO.NE.0 ) THEN

1844                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVR(V,A,' // UPLO //

1845      $               ')', IINFO, N, JTYPE, IOLDSD

1846                   INFO = ABS( IINFO )

1847                   IF( IINFO.LT.0 ) THEN

1848                      RETURN

1849                   ELSE

1850                      RESULT( NTEST ) = ULPINV

1851                      RESULT( NTEST+1 ) = ULPINV

1852                      RESULT( NTEST+2 ) = ULPINV

1853                      GO TO 1170

1854                   END IF

1855                END IF

1856 *

1857 *              Do tests 45 and 46 (or ... )

1858 *

1859                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1860 *

1861                CALL ZHET21( 1, UPLO, N, 0, A, LDU, WA1, D2, Z, LDU, V,

1862      $                      LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1863 *

1864                NTEST = NTEST + 2

1865                CALL ZHEEVR( 'N', 'A', UPLO, N, A, LDU, VL, VU, IL, IU,

1866      $                      ABSTOL, M2, WA2, Z, LDU, IWORK, WORK, LWORK,

1867      $                      RWORK, LRWORK, IWORK( 2*N+1 ), LIWORK-2*N,

1868      $                      IINFO )

1869                IF( IINFO.NE.0 ) THEN

1870                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVR(N,A,' // UPLO //

1871      $               ')', IINFO, N, JTYPE, IOLDSD

1872                   INFO = ABS( IINFO )

1873                   IF( IINFO.LT.0 ) THEN

1874                      RETURN

1875                   ELSE

1876                      RESULT( NTEST ) = ULPINV

1877                      GO TO 1170

1878                   END IF

1879                END IF

1880 *

1881 *              Do test 47 (or ... )

1882 *

1883                TEMP1 = ZERO

1884                TEMP2 = ZERO

1885                DO 1160 J = 1, N

1886                   TEMP1 = MAX( TEMP1, ABS( WA1( J ) ), ABS( WA2( J ) ) )

1887                   TEMP2 = MAX( TEMP2, ABS( WA1( J )-WA2( J ) ) )

1888  1160          CONTINUE

1889                RESULT( NTEST ) = TEMP2 / MAX( UNFL,

1890      $                           ULP*MAX( TEMP1, TEMP2 ) )

1891 *

1892  1170          CONTINUE

1893 *

1894                NTEST = NTEST + 1

1895                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1896                CALL ZHEEVR( 'V', 'I', UPLO, N, A, LDU, VL, VU, IL, IU,

1897      $                      ABSTOL, M2, WA2, Z, LDU, IWORK, WORK, LWORK,

1898      $                      RWORK, LRWORK, IWORK( 2*N+1 ), LIWORK-2*N,

1899      $                      IINFO )

1900                IF( IINFO.NE.0 ) THEN

1901                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVR(V,I,' // UPLO //

1902      $               ')', IINFO, N, JTYPE, IOLDSD

1903                   INFO = ABS( IINFO )

1904                   IF( IINFO.LT.0 ) THEN

1905                      RETURN

1906                   ELSE

1907                      RESULT( NTEST ) = ULPINV

1908                      RESULT( NTEST+1 ) = ULPINV

1909                      RESULT( NTEST+2 ) = ULPINV

1910                      GO TO 1180

1911                   END IF

1912                END IF

1913 *

1914 *              Do tests 48 and 49 (or +??)

1915 *

1916                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1917 *

1918                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

1919      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1920 *

1921                NTEST = NTEST + 2

1922                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1923                CALL ZHEEVR( 'N', 'I', UPLO, N, A, LDU, VL, VU, IL, IU,

1924      $                      ABSTOL, M3, WA3, Z, LDU, IWORK, WORK, LWORK,

1925      $                      RWORK, LRWORK, IWORK( 2*N+1 ), LIWORK-2*N,

1926      $                      IINFO )

1927                IF( IINFO.NE.0 ) THEN

1928                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVR(N,I,' // UPLO //

1929      $               ')', IINFO, N, JTYPE, IOLDSD

1930                   INFO = ABS( IINFO )

1931                   IF( IINFO.LT.0 ) THEN

1932                      RETURN

1933                   ELSE

1934                      RESULT( NTEST ) = ULPINV

1935                      GO TO 1180

1936                   END IF

1937                END IF

1938 *

1939 *              Do test 50 (or +??)

1940 *

1941                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

1942                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

1943                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

1944      $                           MAX( UNFL, ULP*TEMP3 )

1945  1180          CONTINUE

1946 *

1947                NTEST = NTEST + 1

1948                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1949                CALL ZHEEVR( 'V', 'V', UPLO, N, A, LDU, VL, VU, IL, IU,

1950      $                      ABSTOL, M2, WA2, Z, LDU, IWORK, WORK, LWORK,

1951      $                      RWORK, LRWORK, IWORK( 2*N+1 ), LIWORK-2*N,

1952      $                      IINFO )

1953                IF( IINFO.NE.0 ) THEN

1954                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVR(V,V,' // UPLO //

1955      $               ')', IINFO, N, JTYPE, IOLDSD

1956                   INFO = ABS( IINFO )

1957                   IF( IINFO.LT.0 ) THEN

1958                      RETURN

1959                   ELSE

1960                      RESULT( NTEST ) = ULPINV

1961                      RESULT( NTEST+1 ) = ULPINV

1962                      RESULT( NTEST+2 ) = ULPINV

1963                      GO TO 1190

1964                   END IF

1965                END IF

1966 *

1967 *              Do tests 51 and 52 (or +??)

1968 *

1969                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1970 *

1971                CALL ZHET22( 1, UPLO, N, M2, 0, A, LDU, WA2, D2, Z, LDU,

1972      $                      V, LDU, TAU, WORK, RWORK, RESULT( NTEST ) )

1973 *

1974                NTEST = NTEST + 2

1975                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

1976                CALL ZHEEVR( 'N', 'V', UPLO, N, A, LDU, VL, VU, IL, IU,

1977      $                      ABSTOL, M3, WA3, Z, LDU, IWORK, WORK, LWORK,

1978      $                      RWORK, LRWORK, IWORK( 2*N+1 ), LIWORK-2*N,

1979      $                      IINFO )

1980                IF( IINFO.NE.0 ) THEN

1981                   WRITE( NOUNIT, FMT = 9999 )'ZHEEVR(N,V,' // UPLO //

1982      $               ')', IINFO, N, JTYPE, IOLDSD

1983                   INFO = ABS( IINFO )

1984                   IF( IINFO.LT.0 ) THEN

1985                      RETURN

1986                   ELSE

1987                      RESULT( NTEST ) = ULPINV

1988                      GO TO 1190

1989                   END IF

1990                END IF

1991 *

1992                IF( M3.EQ.0 .AND. N.GT.0 ) THEN

1993                   RESULT( NTEST ) = ULPINV

1994                   GO TO 1190

1995                END IF

1996 *

1997 *              Do test 52 (or +??)

1998 *

1999                TEMP1 = DSXT1( 1, WA2, M2, WA3, M3, ABSTOL, ULP, UNFL )

2000                TEMP2 = DSXT1( 1, WA3, M3, WA2, M2, ABSTOL, ULP, UNFL )

2001                IF( N.GT.0 ) THEN

2002                   TEMP3 = MAX( ABS( WA1( 1 ) ), ABS( WA1( N ) ) )

2003                ELSE

2004                   TEMP3 = ZERO

2005                END IF

2006                RESULT( NTEST ) = ( TEMP1+TEMP2 ) /

2007      $                           MAX( UNFL, TEMP3*ULP )

2008 *

2009                CALL ZLACPY( ' ', N, N, V, LDU, A, LDA )

2010 *

2011 *

2012 *

2013 *

2014 *              Load array V with the upper or lower triangular part

2015 *              of the matrix in band form.

2016 *

2017  1190          CONTINUE

2018 *

2019  1200       CONTINUE

2020 *

2021 *           End of Loop -- Check for RESULT(j) > THRESH

2022 *

2023             NTESTT = NTESTT + NTEST

2024             CALL DLAFTS( 'ZST', N, N, JTYPE, NTEST, RESULT, IOLDSD,

2025      $                   THRESH, NOUNIT, NERRS )

2026 *

2027  1210    CONTINUE

2028  1220 CONTINUE

2029 *

2030 *     Summary

2031 *

2032       CALL ALASVM( 'ZST', NOUNIT, NERRS, NTESTT, 0 )

2033 *

2034  9999 FORMAT( ' ZDRVST: ', A, ' returned INFO=', I6, / 9X, 'N=', I6,

2035      $      ', JTYPE=', I6, ', ISEED=(', 3( I5, ',' ), I5, ')' )

2036  9998 FORMAT( ' ZDRVST: ', A, ' returned INFO=', I6, / 9X, 'N=', I6,

2037      $      ', KD=', I6, ', JTYPE=', I6, ', ISEED=(', 3( I5, ',' ), I5,

2038      $      ')' )

2039 *

2040       RETURN

2041 *

2042 *     End of ZDRVST

2043 *

2044       END