zchkst2stg.f

Go to the documentation of this file.

*> \brief \b ZCHKST2STG
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE ZCHKST2STG( NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH,
*                          NOUNIT, A, LDA, AP, SD, SE, D1, D2, D3, D4, D5,
*                          WA1, WA2, WA3, WR, U, LDU, V, VP, TAU, Z, WORK,
*                          LWORK, RWORK, LRWORK, IWORK, LIWORK, RESULT,
*                          INFO )
*
*       .. Scalar Arguments ..
*       INTEGER            INFO, LDA, LDU, LIWORK, LRWORK, LWORK, NOUNIT,
*      $                   NSIZES, NTYPES
*       DOUBLE PRECISION   THRESH
*       ..
*       .. Array Arguments ..
*       LOGICAL            DOTYPE( * )
*       INTEGER            ISEED( 4 ), IWORK( * ), NN( * )
*       DOUBLE PRECISION   D1( * ), D2( * ), D3( * ), D4( * ), D5( * ),
*      $                   RESULT( * ), RWORK( * ), SD( * ), SE( * ),
*      $                   WA1( * ), WA2( * ), WA3( * ), WR( * )
*       COMPLEX*16         A( LDA, * ), AP( * ), TAU( * ), U( LDU, * ),
*      $                   V( LDU, * ), VP( * ), WORK( * ), Z( LDU, * )
*       ..
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> ZCHKST2STG  checks the Hermitian eigenvalue problem routines
*> using the 2-stage reduction techniques. Since the generation
*> of Q or the vectors is not available in this release, we only 
*> compare the eigenvalue resulting when using the 2-stage to the 
*> one considered as reference using the standard 1-stage reduction
*> ZHETRD. For that, we call the standard ZHETRD and compute D1 using 
*> DSTEQR, then we call the 2-stage ZHETRD_2STAGE with Upper and Lower
*> and we compute D2 and D3 using DSTEQR and then we replaced tests
*> 3 and 4 by tests 11 and 12. test 1 and 2 remain to verify that 
*> the 1-stage results are OK and can be trusted.
*> This testing routine will converge to the ZCHKST in the next 
*> release when vectors and generation of Q will be implemented.
*>
*>    ZHETRD factors A as  U S U* , where * means conjugate transpose,
*>    S is real symmetric tridiagonal, and U is unitary.
*>    ZHETRD can use either just the lower or just the upper triangle
*>    of A; ZCHKST2STG checks both cases.
*>    U is represented as a product of Householder
*>    transformations, whose vectors are stored in the first
*>    n-1 columns of V, and whose scale factors are in TAU.
*>
*>    ZHPTRD does the same as ZHETRD, except that A and V are stored
*>    in "packed" format.
*>
*>    ZUNGTR constructs the matrix U from the contents of V and TAU.
*>
*>    ZUPGTR constructs the matrix U from the contents of VP and TAU.
*>
*>    ZSTEQR factors S as  Z D1 Z* , where Z is the unitary
*>    matrix of eigenvectors and D1 is a diagonal matrix with
*>    the eigenvalues on the diagonal.  D2 is the matrix of
*>    eigenvalues computed when Z is not computed.
*>
*>    DSTERF computes D3, the matrix of eigenvalues, by the
*>    PWK method, which does not yield eigenvectors.
*>
*>    ZPTEQR factors S as  Z4 D4 Z4* , for a
*>    Hermitian positive definite tridiagonal matrix.
*>    D5 is the matrix of eigenvalues computed when Z is not
*>    computed.
*>
*>    DSTEBZ computes selected eigenvalues.  WA1, WA2, and
*>    WA3 will denote eigenvalues computed to high
*>    absolute accuracy, with different range options.
*>    WR will denote eigenvalues computed to high relative
*>    accuracy.
*>
*>    ZSTEIN computes Y, the eigenvectors of S, given the
*>    eigenvalues.
*>
*>    ZSTEDC factors S as Z D1 Z* , where Z is the unitary
*>    matrix of eigenvectors and D1 is a diagonal matrix with
*>    the eigenvalues on the diagonal ('I' option). It may also
*>    update an input unitary matrix, usually the output
*>    from ZHETRD/ZUNGTR or ZHPTRD/ZUPGTR ('V' option). It may
*>    also just compute eigenvalues ('N' option).
*>
*>    ZSTEMR factors S as Z D1 Z* , where Z is the unitary
*>    matrix of eigenvectors and D1 is a diagonal matrix with
*>    the eigenvalues on the diagonal ('I' option).  ZSTEMR
*>    uses the Relatively Robust Representation whenever possible.
*>
*> When ZCHKST2STG is called, a number of matrix "sizes" ("n's") and a
*> number of matrix "types" are specified.  For each size ("n")
*> and each type of matrix, one matrix will be generated and used
*> to test the Hermitian eigenroutines.  For each matrix, a number
*> of tests will be performed:
*>
*> (1)     | A - V S V* | / ( |A| n ulp ) ZHETRD( UPLO='U', ... )
*>
*> (2)     | I - UV* | / ( n ulp )        ZUNGTR( UPLO='U', ... )
*>
*> (3)     | A - V S V* | / ( |A| n ulp ) ZHETRD( UPLO='L', ... )
*>         replaced by | D1 - D2 | / ( |D1| ulp ) where D1 is the 
*>         eigenvalue matrix computed using S and D2 is the 
*>         eigenvalue matrix computed using S_2stage the output of
*>         ZHETRD_2STAGE("N", "U",....). D1 and D2 are computed 
*>         via DSTEQR('N',...) 
*>
*> (4)     | I - UV* | / ( n ulp )        ZUNGTR( UPLO='L', ... )
*>         replaced by | D1 - D3 | / ( |D1| ulp ) where D1 is the 
*>         eigenvalue matrix computed using S and D3 is the 
*>         eigenvalue matrix computed using S_2stage the output of
*>         ZHETRD_2STAGE("N", "L",....). D1 and D3 are computed 
*>         via DSTEQR('N',...)  
*>
*> (5-8)   Same as 1-4, but for ZHPTRD and ZUPGTR.
*>
*> (9)     | S - Z D Z* | / ( |S| n ulp ) ZSTEQR('V',...)
*>
*> (10)    | I - ZZ* | / ( n ulp )        ZSTEQR('V',...)
*>
*> (11)    | D1 - D2 | / ( |D1| ulp )        ZSTEQR('N',...)
*>
*> (12)    | D1 - D3 | / ( |D1| ulp )        DSTERF
*>
*> (13)    0 if the true eigenvalues (computed by sturm count)
*>         of S are within THRESH of
*>         those in D1.  2*THRESH if they are not.  (Tested using
*>         DSTECH)
*>
*> For S positive definite,
*>
*> (14)    | S - Z4 D4 Z4* | / ( |S| n ulp ) ZPTEQR('V',...)
*>
*> (15)    | I - Z4 Z4* | / ( n ulp )        ZPTEQR('V',...)
*>
*> (16)    | D4 - D5 | / ( 100 |D4| ulp )       ZPTEQR('N',...)
*>
*> When S is also diagonally dominant by the factor gamma < 1,
*>
*> (17)    max | D4(i) - WR(i) | / ( |D4(i)| omega ) ,
*>          i
*>         omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
*>                                              DSTEBZ( 'A', 'E', ...)
*>
*> (18)    | WA1 - D3 | / ( |D3| ulp )          DSTEBZ( 'A', 'E', ...)
*>
*> (19)    ( max { min | WA2(i)-WA3(j) | } +
*>            i     j
*>           max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
*>            i     j
*>                                              DSTEBZ( 'I', 'E', ...)
*>
*> (20)    | S - Y WA1 Y* | / ( |S| n ulp )  DSTEBZ, ZSTEIN
*>
*> (21)    | I - Y Y* | / ( n ulp )          DSTEBZ, ZSTEIN
*>
*> (22)    | S - Z D Z* | / ( |S| n ulp )    ZSTEDC('I')
*>
*> (23)    | I - ZZ* | / ( n ulp )           ZSTEDC('I')
*>
*> (24)    | S - Z D Z* | / ( |S| n ulp )    ZSTEDC('V')
*>
*> (25)    | I - ZZ* | / ( n ulp )           ZSTEDC('V')
*>
*> (26)    | D1 - D2 | / ( |D1| ulp )           ZSTEDC('V') and
*>                                              ZSTEDC('N')
*>
*> Test 27 is disabled at the moment because ZSTEMR does not
*> guarantee high relatvie accuracy.
*>
*> (27)    max | D6(i) - WR(i) | / ( |D6(i)| omega ) ,
*>          i
*>         omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
*>                                              ZSTEMR('V', 'A')
*>
*> (28)    max | D6(i) - WR(i) | / ( |D6(i)| omega ) ,
*>          i
*>         omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
*>                                              ZSTEMR('V', 'I')
*>
*> Tests 29 through 34 are disable at present because ZSTEMR
*> does not handle partial spectrum requests.
*>
*> (29)    | S - Z D Z* | / ( |S| n ulp )    ZSTEMR('V', 'I')
*>
*> (30)    | I - ZZ* | / ( n ulp )           ZSTEMR('V', 'I')
*>
*> (31)    ( max { min | WA2(i)-WA3(j) | } +
*>            i     j
*>           max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
*>            i     j
*>         ZSTEMR('N', 'I') vs. CSTEMR('V', 'I')
*>
*> (32)    | S - Z D Z* | / ( |S| n ulp )    ZSTEMR('V', 'V')
*>
*> (33)    | I - ZZ* | / ( n ulp )           ZSTEMR('V', 'V')
*>
*> (34)    ( max { min | WA2(i)-WA3(j) | } +
*>            i     j
*>           max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
*>            i     j
*>         ZSTEMR('N', 'V') vs. CSTEMR('V', 'V')
*>
*> (35)    | S - Z D Z* | / ( |S| n ulp )    ZSTEMR('V', 'A')
*>
*> (36)    | I - ZZ* | / ( n ulp )           ZSTEMR('V', 'A')
*>
*> (37)    ( max { min | WA2(i)-WA3(j) | } +
*>            i     j
*>           max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
*>            i     j
*>         ZSTEMR('N', 'A') vs. CSTEMR('V', 'A')
*>
*> The "sizes" are specified by an array NN(1:NSIZES); the value of
*> each element NN(j) specifies one size.
*> The "types" are specified by a logical array DOTYPE( 1:NTYPES );
*> if DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
*> Currently, the list of possible types is:
*>
*> (1)  The zero matrix.
*> (2)  The identity matrix.
*>
*> (3)  A diagonal matrix with evenly spaced entries
*>      1, ..., ULP  and random signs.
*>      (ULP = (first number larger than 1) - 1 )
*> (4)  A diagonal matrix with geometrically spaced entries
*>      1, ..., ULP  and random signs.
*> (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
*>      and random signs.
*>
*> (6)  Same as (4), but multiplied by SQRT( overflow threshold )
*> (7)  Same as (4), but multiplied by SQRT( underflow threshold )
*>
*> (8)  A matrix of the form  U* D U, where U is unitary and
*>      D has evenly spaced entries 1, ..., ULP with random signs
*>      on the diagonal.
*>
*> (9)  A matrix of the form  U* D U, where U is unitary and
*>      D has geometrically spaced entries 1, ..., ULP with random
*>      signs on the diagonal.
*>
*> (10) A matrix of the form  U* D U, where U is unitary and
*>      D has "clustered" entries 1, ULP,..., ULP with random
*>      signs on the diagonal.
*>
*> (11) Same as (8), but multiplied by SQRT( overflow threshold )
*> (12) Same as (8), but multiplied by SQRT( underflow threshold )
*>
*> (13) Hermitian matrix with random entries chosen from (-1,1).
*> (14) Same as (13), but multiplied by SQRT( overflow threshold )
*> (15) Same as (13), but multiplied by SQRT( underflow threshold )
*> (16) Same as (8), but diagonal elements are all positive.
*> (17) Same as (9), but diagonal elements are all positive.
*> (18) Same as (10), but diagonal elements are all positive.
*> (19) Same as (16), but multiplied by SQRT( overflow threshold )
*> (20) Same as (16), but multiplied by SQRT( underflow threshold )
*> (21) A diagonally dominant tridiagonal matrix with geometrically
*>      spaced diagonal entries 1, ..., ULP.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] NSIZES
*> \verbatim
*>          NSIZES is INTEGER
*>          The number of sizes of matrices to use.  If it is zero,
*>          ZCHKST2STG does nothing.  It must be at least zero.
*> \endverbatim
*>
*> \param[in] NN
*> \verbatim
*>          NN is INTEGER array, dimension (NSIZES)
*>          An array containing the sizes to be used for the matrices.
*>          Zero values will be skipped.  The values must be at least
*>          zero.
*> \endverbatim
*>
*> \param[in] NTYPES
*> \verbatim
*>          NTYPES is INTEGER
*>          The number of elements in DOTYPE.   If it is zero, ZCHKST2STG
*>          does nothing.  It must be at least zero.  If it is MAXTYP+1
*>          and NSIZES is 1, then an additional type, MAXTYP+1 is
*>          defined, which is to use whatever matrix is in A.  This
*>          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
*>          DOTYPE(MAXTYP+1) is .TRUE. .
*> \endverbatim
*>
*> \param[in] DOTYPE
*> \verbatim
*>          DOTYPE is LOGICAL array, dimension (NTYPES)
*>          If DOTYPE(j) is .TRUE., then for each size in NN a
*>          matrix of that size and of type j will be generated.
*>          If NTYPES is smaller than the maximum number of types
*>          defined (PARAMETER MAXTYP), then types NTYPES+1 through
*>          MAXTYP will not be generated.  If NTYPES is larger
*>          than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES)
*>          will be ignored.
*> \endverbatim
*>
*> \param[in,out] ISEED
*> \verbatim
*>          ISEED is INTEGER array, dimension (4)
*>          On entry ISEED specifies the seed of the random number
*>          generator. The array elements should be between 0 and 4095;
*>          if not they will be reduced mod 4096.  Also, ISEED(4) must
*>          be odd.  The random number generator uses a linear
*>          congruential sequence limited to small integers, and so
*>          should produce machine independent random numbers. The
*>          values of ISEED are changed on exit, and can be used in the
*>          next call to ZCHKST2STG to continue the same random number
*>          sequence.
*> \endverbatim
*>
*> \param[in] THRESH
*> \verbatim
*>          THRESH is DOUBLE PRECISION
*>          A test will count as "failed" if the "error", computed as
*>          described above, exceeds THRESH.  Note that the error
*>          is scaled to be O(1), so THRESH should be a reasonably
*>          small multiple of 1, e.g., 10 or 100.  In particular,
*>          it should not depend on the precision (single vs. double)
*>          or the size of the matrix.  It must be at least zero.
*> \endverbatim
*>
*> \param[in] NOUNIT
*> \verbatim
*>          NOUNIT is INTEGER
*>          The FORTRAN unit number for printing out error messages
*>          (e.g., if a routine returns IINFO not equal to 0.)
*> \endverbatim
*>
*> \param[in,out] A
*> \verbatim
*>          A is COMPLEX*16 array of
*>                                  dimension ( LDA , max(NN) )
*>          Used to hold the matrix whose eigenvalues are to be
*>          computed.  On exit, A contains the last matrix actually
*>          used.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>          LDA is INTEGER
*>          The leading dimension of A.  It must be at
*>          least 1 and at least max( NN ).
*> \endverbatim
*>
*> \param[out] AP
*> \verbatim
*>          AP is COMPLEX*16 array of
*>                      dimension( max(NN)*max(NN+1)/2 )
*>          The matrix A stored in packed format.
*> \endverbatim
*>
*> \param[out] SD
*> \verbatim
*>          SD is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The diagonal of the tridiagonal matrix computed by ZHETRD.
*>          On exit, SD and SE contain the tridiagonal form of the
*>          matrix in A.
*> \endverbatim
*>
*> \param[out] SE
*> \verbatim
*>          SE is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The off-diagonal of the tridiagonal matrix computed by
*>          ZHETRD.  On exit, SD and SE contain the tridiagonal form of
*>          the matrix in A.
*> \endverbatim
*>
*> \param[out] D1
*> \verbatim
*>          D1 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The eigenvalues of A, as computed by ZSTEQR simlutaneously
*>          with Z.  On exit, the eigenvalues in D1 correspond with the
*>          matrix in A.
*> \endverbatim
*>
*> \param[out] D2
*> \verbatim
*>          D2 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The eigenvalues of A, as computed by ZSTEQR if Z is not
*>          computed.  On exit, the eigenvalues in D2 correspond with
*>          the matrix in A.
*> \endverbatim
*>
*> \param[out] D3
*> \verbatim
*>          D3 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The eigenvalues of A, as computed by DSTERF.  On exit, the
*>          eigenvalues in D3 correspond with the matrix in A.
*> \endverbatim
*>
*> \param[out] D4
*> \verbatim
*>          D4 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The eigenvalues of A, as computed by ZPTEQR(V).
*>          ZPTEQR factors S as  Z4 D4 Z4*
*>          On exit, the eigenvalues in D4 correspond with the matrix in A.
*> \endverbatim
*>
*> \param[out] D5
*> \verbatim
*>          D5 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          The eigenvalues of A, as computed by ZPTEQR(N)
*>          when Z is not computed. On exit, the
*>          eigenvalues in D4 correspond with the matrix in A.
*> \endverbatim
*>
*> \param[out] WA1
*> \verbatim
*>          WA1 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          All eigenvalues of A, computed to high
*>          absolute accuracy, with different range options.
*>          as computed by DSTEBZ.
*> \endverbatim
*>
*> \param[out] WA2
*> \verbatim
*>          WA2 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          Selected eigenvalues of A, computed to high
*>          absolute accuracy, with different range options.
*>          as computed by DSTEBZ.
*>          Choose random values for IL and IU, and ask for the
*>          IL-th through IU-th eigenvalues.
*> \endverbatim
*>
*> \param[out] WA3
*> \verbatim
*>          WA3 is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          Selected eigenvalues of A, computed to high
*>          absolute accuracy, with different range options.
*>          as computed by DSTEBZ.
*>          Determine the values VL and VU of the IL-th and IU-th
*>          eigenvalues and ask for all eigenvalues in this range.
*> \endverbatim
*>
*> \param[out] WR
*> \verbatim
*>          WR is DOUBLE PRECISION array of
*>                             dimension( max(NN) )
*>          All eigenvalues of A, computed to high
*>          absolute accuracy, with different options.
*>          as computed by DSTEBZ.
*> \endverbatim
*>
*> \param[out] U
*> \verbatim
*>          U is COMPLEX*16 array of
*>                             dimension( LDU, max(NN) ).
*>          The unitary matrix computed by ZHETRD + ZUNGTR.
*> \endverbatim
*>
*> \param[in] LDU
*> \verbatim
*>          LDU is INTEGER
*>          The leading dimension of U, Z, and V.  It must be at least 1
*>          and at least max( NN ).
*> \endverbatim
*>
*> \param[out] V
*> \verbatim
*>          V is COMPLEX*16 array of
*>                             dimension( LDU, max(NN) ).
*>          The Housholder vectors computed by ZHETRD in reducing A to
*>          tridiagonal form.  The vectors computed with UPLO='U' are
*>          in the upper triangle, and the vectors computed with UPLO='L'
*>          are in the lower triangle.  (As described in ZHETRD, the
*>          sub- and superdiagonal are not set to 1, although the
*>          true Householder vector has a 1 in that position.  The
*>          routines that use V, such as ZUNGTR, set those entries to
*>          1 before using them, and then restore them later.)
*> \endverbatim
*>
*> \param[out] VP
*> \verbatim
*>          VP is COMPLEX*16 array of
*>                      dimension( max(NN)*max(NN+1)/2 )
*>          The matrix V stored in packed format.
*> \endverbatim
*>
*> \param[out] TAU
*> \verbatim
*>          TAU is COMPLEX*16 array of
*>                             dimension( max(NN) )
*>          The Householder factors computed by ZHETRD in reducing A
*>          to tridiagonal form.
*> \endverbatim
*>
*> \param[out] Z
*> \verbatim
*>          Z is COMPLEX*16 array of
*>                             dimension( LDU, max(NN) ).
*>          The unitary matrix of eigenvectors computed by ZSTEQR,
*>          ZPTEQR, and ZSTEIN.
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is COMPLEX*16 array of
*>                      dimension( LWORK )
*> \endverbatim
*>
*> \param[in] LWORK
*> \verbatim
*>          LWORK is INTEGER
*>          The number of entries in WORK.  This must be at least
*>          1 + 4 * Nmax + 2 * Nmax * lg Nmax + 3 * Nmax**2
*>          where Nmax = max( NN(j), 2 ) and lg = log base 2.
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array,
*>          Workspace.
*> \endverbatim
*>
*> \param[out] LIWORK
*> \verbatim
*>          LIWORK is INTEGER
*>          The number of entries in IWORK.  This must be at least
*>                  6 + 6*Nmax + 5 * Nmax * lg Nmax
*>          where Nmax = max( NN(j), 2 ) and lg = log base 2.
*> \endverbatim
*>
*> \param[out] RWORK
*> \verbatim
*>          RWORK is DOUBLE PRECISION array
*> \endverbatim
*>
*> \param[in] LRWORK
*> \verbatim
*>          LRWORK is INTEGER
*>          The number of entries in LRWORK (dimension( ??? )
*> \endverbatim
*>
*> \param[out] RESULT
*> \verbatim
*>          RESULT is DOUBLE PRECISION array, dimension (26)
*>          The values computed by the tests described above.
*>          The values are currently limited to 1/ulp, to avoid
*>          overflow.
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*>          INFO is INTEGER
*>          If 0, then everything ran OK.
*>           -1: NSIZES < 0
*>           -2: Some NN(j) < 0
*>           -3: NTYPES < 0
*>           -5: THRESH < 0
*>           -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
*>          -23: LDU < 1 or LDU < NMAX.
*>          -29: LWORK too small.
*>          If  ZLATMR, CLATMS, ZHETRD, ZUNGTR, ZSTEQR, DSTERF,
*>              or ZUNMC2 returns an error code, the
*>              absolute value of it is returned.
*>
*>-----------------------------------------------------------------------
*>
*>       Some Local Variables and Parameters:
*>       ---- ----- --------- --- ----------
*>       ZERO, ONE       Real 0 and 1.
*>       MAXTYP          The number of types defined.
*>       NTEST           The number of tests performed, or which can
*>                       be performed so far, for the current matrix.
*>       NTESTT          The total number of tests performed so far.
*>       NBLOCK          Blocksize as returned by ENVIR.
*>       NMAX            Largest value in NN.
*>       NMATS           The number of matrices generated so far.
*>       NERRS           The number of tests which have exceeded THRESH
*>                       so far.
*>       COND, IMODE     Values to be passed to the matrix generators.
*>       ANORM           Norm of A; passed to matrix generators.
*>
*>       OVFL, UNFL      Overflow and underflow thresholds.
*>       ULP, ULPINV     Finest relative precision and its inverse.
*>       RTOVFL, RTUNFL  Square roots of the previous 2 values.
*>               The following four arrays decode JTYPE:
*>       KTYPE(j)        The general type (1-10) for type "j".
*>       KMODE(j)        The MODE value to be passed to the matrix
*>                       generator for type "j".
*>       KMAGN(j)        The order of magnitude ( O(1),
*>                       O(overflow^(1/2) ), O(underflow^(1/2) )
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup complex16_eig
*
*  =====================================================================
      SUBROUTINE zchkst2stg( NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH,
     $                   NOUNIT, A, LDA, AP, SD, SE, D1, D2, D3, D4, D5,
     $                   WA1, WA2, WA3, WR, U, LDU, V, VP, TAU, Z, WORK,
     $                   LWORK, RWORK, LRWORK, IWORK, LIWORK, RESULT,
     $                   INFO )
*
*  -- LAPACK test routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            INFO, LDA, LDU, LIWORK, LRWORK, LWORK, NOUNIT,
     $                   NSIZES, NTYPES
      DOUBLE PRECISION   THRESH
*     ..
*     .. Array Arguments ..
      LOGICAL            DOTYPE( * )
      INTEGER            ISEED( 4 ), IWORK( * ), NN( * )
      DOUBLE PRECISION   D1( * ), D2( * ), D3( * ), D4( * ), D5( * ),
     $                   RESULT( * ), RWORK( * ), SD( * ), SE( * ),
     $                   wa1( * ), wa2( * ), wa3( * ), wr( * )
      COMPLEX*16         A( LDA, * ), AP( * ), TAU( * ), U( LDU, * ),
     $                   v( ldu, * ), vp( * ), work( * ), z( ldu, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ZERO, ONE, TWO, EIGHT, TEN, HUN
      PARAMETER          ( ZERO = 0.0d0, one = 1.0d0, two = 2.0d0,
     $                   eight = 8.0d0, ten = 10.0d0, hun = 100.0d0 )
      COMPLEX*16         CZERO, CONE
      parameter( czero = ( 0.0d+0, 0.0d+0 ),
     $                   cone = ( 1.0d+0, 0.0d+0 ) )
      DOUBLE PRECISION   HALF
      parameter( half = one / two )
      INTEGER            MAXTYP
      PARAMETER          ( MAXTYP = 21 )
      LOGICAL            CRANGE
      parameter( crange = .false. )
      LOGICAL            CREL
      parameter( crel = .false. )
*     ..
*     .. Local Scalars ..
      LOGICAL            BADNN, TRYRAC
      INTEGER            I, IINFO, IL, IMODE, INDE, INDRWK, ITEMP,
     $                   ITYPE, IU, J, JC, JR, JSIZE, JTYPE, LGN,
     $                   LIWEDC, LOG2UI, LRWEDC, LWEDC, M, M2, M3,
     $                   mtypes, n, nap, nblock, nerrs, nmats, nmax,
     $                   nsplit, ntest, ntestt, lh, lw
      DOUBLE PRECISION   ABSTOL, ANINV, ANORM, COND, OVFL, RTOVFL,
     $                   RTUNFL, TEMP1, TEMP2, TEMP3, TEMP4, ULP,
     $                   ULPINV, UNFL, VL, VU
*     ..
*     .. Local Arrays ..
      INTEGER            IDUMMA( 1 ), IOLDSD( 4 ), ISEED2( 4 ),
     $                   KMAGN( MAXTYP ), KMODE( MAXTYP ),
     $                   KTYPE( MAXTYP )
      DOUBLE PRECISION   DUMMA( 1 )
*     ..
*     .. External Functions ..
      INTEGER            ILAENV
      DOUBLE PRECISION   DLAMCH, DLARND, DSXT1
      EXTERNAL           ILAENV, DLAMCH, DLARND, DSXT1
*     ..
*     .. External Subroutines ..
      EXTERNAL           dcopy, dlabad, dlasum, dstebz, dstech, dsterf,
     $                   xerbla, zcopy, zhet21, zhetrd, zhpt21, zhptrd,
     $                   zlacpy, zlaset, zlatmr, zlatms, zpteqr, zstedc,
     $                   zstemr, zstein, zsteqr, zstt21, zstt22, zungtr,
     $                   zupgtr, zhetrd_2stage
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dble, dconjg, int, log, max, min, sqrt
*     ..
*     .. Data statements ..
      DATA               ktype / 1, 2, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 8,
     $                   8, 8, 9, 9, 9, 9, 9, 10 /
      DATA               kmagn / 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 1,
     $                   2, 3, 1, 1, 1, 2, 3, 1 /
      DATA               kmode / 0, 0, 4, 3, 1, 4, 4, 4, 3, 1, 4, 4, 0,
     $                   0, 0, 4, 3, 1, 4, 4, 3 /
*     ..
*     .. Executable Statements ..
*
*     Keep ftnchek happy
      idumma( 1 ) = 1
*
*     Check for errors
*
      ntestt = 0
      info = 0
*
*     Important constants
*
      badnn = .false.
      tryrac = .true.
      nmax = 1
      DO 10 j = 1, nsizes
         nmax = max( nmax, nn( j ) )
         IF( nn( j ).LT.0 )
     $      badnn = .true.
   10 CONTINUE
*
      nblock = ilaenv( 1, 'ZHETRD', 'L', nmax, -1, -1, -1 )
      nblock = min( nmax, max( 1, nblock ) )
*
*     Check for errors
*
      IF( nsizes.LT.0 ) THEN
         info = -1
      ELSE IF( badnn ) THEN
         info = -2
      ELSE IF( ntypes.LT.0 ) THEN
         info = -3
      ELSE IF( lda.LT.nmax ) THEN
         info = -9
      ELSE IF( ldu.LT.nmax ) THEN
         info = -23
      ELSE IF( 2*max( 2, nmax )**2.GT.lwork ) THEN
         info = -29
      END IF
*
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZCHKST2STG', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( nsizes.EQ.0 .OR. ntypes.EQ.0 )
     $   RETURN
*
*     More Important constants
*
      unfl = dlamch( 'Safe minimum' )
      ovfl = one / unfl
      CALL dlabad( unfl, ovfl )
      ulp = dlamch( 'Epsilon' )*dlamch( 'Base' )
      ulpinv = one / ulp
      log2ui = int( log( ulpinv ) / log( two ) )
      rtunfl = sqrt( unfl )
      rtovfl = sqrt( ovfl )
*
*     Loop over sizes, types
*
      DO 20 i = 1, 4
         iseed2( i ) = iseed( i )
   20 CONTINUE
      nerrs = 0
      nmats = 0
*
      DO 310 jsize = 1, nsizes
         n = nn( jsize )
         IF( n.GT.0 ) THEN
            lgn = int( log( dble( n ) ) / log( two ) )
            IF( 2**lgn.LT.n )
     $         lgn = lgn + 1
            IF( 2**lgn.LT.n )
     $         lgn = lgn + 1
            lwedc = 1 + 4*n + 2*n*lgn + 4*n**2
            lrwedc = 1 + 3*n + 2*n*lgn + 4*n**2
            liwedc = 6 + 6*n + 5*n*lgn
         ELSE
            lwedc = 8
            lrwedc = 7
            liwedc = 12
         END IF
         nap = ( n*( n+1 ) ) / 2
         aninv = one / dble( max( 1, n ) )
*
         IF( nsizes.NE.1 ) THEN
            mtypes = min( maxtyp, ntypes )
         ELSE
            mtypes = min( maxtyp+1, ntypes )
         END IF
*
         DO 300 jtype = 1, mtypes
            IF( .NOT.dotype( jtype ) )
     $         GO TO 300
            nmats = nmats + 1
            ntest = 0
*
            DO 30 j = 1, 4
               ioldsd( j ) = iseed( j )
   30       CONTINUE
*
*           Compute "A"
*
*           Control parameters:
*
*               KMAGN  KMODE        KTYPE
*           =1  O(1)   clustered 1  zero
*           =2  large  clustered 2  identity
*           =3  small  exponential  (none)
*           =4         arithmetic   diagonal, (w/ eigenvalues)
*           =5         random log   Hermitian, w/ eigenvalues
*           =6         random       (none)
*           =7                      random diagonal
*           =8                      random Hermitian
*           =9                      positive definite
*           =10                     diagonally dominant tridiagonal
*
            IF( mtypes.GT.maxtyp )
     $         GO TO 100
*
            itype = ktype( jtype )
            imode = kmode( jtype )
*
*           Compute norm
*
            GO TO ( 40, 50, 60 )kmagn( jtype )
*
   40       CONTINUE
            anorm = one
            GO TO 70
*
   50       CONTINUE
            anorm = ( rtovfl*ulp )*aninv
            GO TO 70
*
   60       CONTINUE
            anorm = rtunfl*n*ulpinv
            GO TO 70
*
   70       CONTINUE
*
            CALL zlaset( 'Full', lda, n, czero, czero, a, lda )
            iinfo = 0
            IF( jtype.LE.15 ) THEN
               cond = ulpinv
            ELSE
               cond = ulpinv*aninv / ten
            END IF
*
*           Special Matrices -- Identity & Jordan block
*
*              Zero
*
            IF( itype.EQ.1 ) THEN
               iinfo = 0
*
            ELSE IF( itype.EQ.2 ) THEN
*
*              Identity
*
               DO 80 jc = 1, n
                  a( jc, jc ) = anorm
   80          CONTINUE
*
            ELSE IF( itype.EQ.4 ) THEN
*
*              Diagonal Matrix, [Eigen]values Specified
*
               CALL zlatms( n, n, 'S', iseed, 'H', rwork, imode, cond,
     $                      anorm, 0, 0, 'N', a, lda, work, iinfo )
*
*
            ELSE IF( itype.EQ.5 ) THEN
*
*              Hermitian, eigenvalues specified
*
               CALL zlatms( n, n, 'S', iseed, 'H', rwork, imode, cond,
     $                      anorm, n, n, 'N', a, lda, work, iinfo )
*
            ELSE IF( itype.EQ.7 ) THEN
*
*              Diagonal, random eigenvalues
*
               CALL zlatmr( n, n, 'S', iseed, 'H', work, 6, one, cone,
     $                      'T', 'N', work( n+1 ), 1, one,
     $                      work( 2*n+1 ), 1, one, 'N', idumma, 0, 0,
     $                      zero, anorm, 'NO', a, lda, iwork, iinfo )
*
            ELSE IF( itype.EQ.8 ) THEN
*
*              Hermitian, random eigenvalues
*
               CALL zlatmr( n, n, 'S', iseed, 'H', work, 6, one, cone,
     $                      'T', 'N', work( n+1 ), 1, one,
     $                      work( 2*n+1 ), 1, one, 'N', idumma, n, n,
     $                      zero, anorm, 'NO', a, lda, iwork, iinfo )
*
            ELSE IF( itype.EQ.9 ) THEN
*
*              Positive definite, eigenvalues specified.
*
               CALL zlatms( n, n, 'S', iseed, 'P', rwork, imode, cond,
     $                      anorm, n, n, 'N', a, lda, work, iinfo )
*
            ELSE IF( itype.EQ.10 ) THEN
*
*              Positive definite tridiagonal, eigenvalues specified.
*
               CALL zlatms( n, n, 'S', iseed, 'P', rwork, imode, cond,
     $                      anorm, 1, 1, 'N', a, lda, work, iinfo )
               DO 90 i = 2, n
                  temp1 = abs( a( i-1, i ) )
                  temp2 = sqrt( abs( a( i-1, i-1 )*a( i, i ) ) )
                  IF( temp1.GT.half*temp2 ) THEN
                     a( i-1, i ) = a( i-1, i )*
     $                             ( half*temp2 / ( unfl+temp1 ) )
                     a( i, i-1 ) = dconjg( a( i-1, i ) )
                  END IF
   90          CONTINUE
*
            ELSE
*
               iinfo = 1
            END IF
*
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'Generator', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               RETURN
            END IF
*
  100       CONTINUE
*
*           Call ZHETRD and ZUNGTR to compute S and U from
*           upper triangle.
*
            CALL zlacpy( 'U', n, n, a, lda, v, ldu )
*
            ntest = 1
            CALL zhetrd( 'U', n, v, ldu, sd, se, tau, work, lwork,
     $                   iinfo )
*
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZHETRD(U)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 1 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
            CALL zlacpy( 'U', n, n, v, ldu, u, ldu )
*
            ntest = 2
            CALL zungtr( 'U', n, u, ldu, tau, work, lwork, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZUNGTR(U)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 2 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do tests 1 and 2
*
            CALL zhet21( 2, 'Upper', n, 1, a, lda, sd, se, u, ldu, v,
     $                   ldu, tau, work, rwork, result( 1 ) )
            CALL zhet21( 3, 'Upper', n, 1, a, lda, sd, se, u, ldu, v,
     $                   ldu, tau, work, rwork, result( 2 ) )
*
*           Compute D1 the eigenvalues resulting from the tridiagonal
*           form using the standard 1-stage algorithm and use it as a
*           reference to compare with the 2-stage technique
*
*           Compute D1 from the 1-stage and used as reference for the
*           2-stage
*
            CALL dcopy( n, sd, 1, d1, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork, 1 )
*
            CALL zsteqr( 'N', n, d1, rwork, work, ldu, rwork( n+1 ),
     $                   iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEQR(N)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 3 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           2-STAGE TRD Upper case is used to compute D2.
*           Note to set SD and SE to zero to be sure not reusing 
*           the one from above. Compare it with D1 computed 
*           using the 1-stage.
*
            CALL dlaset( 'Full', n, 1, zero, zero, sd, n )
            CALL dlaset( 'Full', n, 1, zero, zero, se, n )
            CALL zlacpy( 'U', n, n, a, lda, v, ldu )
            lh = max(1, 4*n)
            lw = lwork - lh
            CALL zhetrd_2stage( 'N', "U", n, v, ldu, sd, se, tau, 
     $                   work, lh, work( lh+1 ), lw, iinfo )
*
*           Compute D2 from the 2-stage Upper case
*
            CALL dcopy( n, sd, 1, d2, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork, 1 )
*
            ntest = 3
            CALL zsteqr( 'N', n, d2, rwork, work, ldu, rwork( n+1 ),
     $                   iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEQR(N)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 3 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           2-STAGE TRD Lower case is used to compute D3.
*           Note to set SD and SE to zero to be sure not reusing 
*           the one from above. Compare it with D1 computed 
*           using the 1-stage. 
*
            CALL dlaset( 'Full', n, 1, zero, zero, sd, n )
            CALL dlaset( 'Full', n, 1, zero, zero, se, n )
            CALL zlacpy( 'L', n, n, a, lda, v, ldu )
            CALL zhetrd_2stage( 'N', "L", n, v, ldu, sd, se, tau, 
     $                   work, lh, work( lh+1 ), lw, iinfo )
*
*           Compute D3 from the 2-stage Upper case
*
            CALL dcopy( n, sd, 1, d3, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork, 1 )
*
            ntest = 4
            CALL zsteqr( 'N', n, d3, rwork, work, ldu, rwork( n+1 ),
     $                   iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEQR(N)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 4 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*
*           Do Tests 3 and 4 which are similar to 11 and 12 but with the
*           D1 computed using the standard 1-stage reduction as reference
*
            ntest = 4
            temp1 = zero
            temp2 = zero
            temp3 = zero
            temp4 = zero
*
            DO 151 j = 1, n
               temp1 = max( temp1, abs( d1( j ) ), abs( d2( j ) ) )
               temp2 = max( temp2, abs( d1( j )-d2( j ) ) )
               temp3 = max( temp3, abs( d1( j ) ), abs( d3( j ) ) )
               temp4 = max( temp4, abs( d1( j )-d3( j ) ) )
  151       CONTINUE
*
            result( 3 ) = temp2 / max( unfl, ulp*max( temp1, temp2 ) )
            result( 4 ) = temp4 / max( unfl, ulp*max( temp3, temp4 ) )
*
*           Store the upper triangle of A in AP
*
            i = 0
            DO 120 jc = 1, n
               DO 110 jr = 1, jc
                  i = i + 1
                  ap( i ) = a( jr, jc )
  110          CONTINUE
  120       CONTINUE
*
*           Call ZHPTRD and ZUPGTR to compute S and U from AP
*
            CALL zcopy( nap, ap, 1, vp, 1 )
*
            ntest = 5
            CALL zhptrd( 'U', n, vp, sd, se, tau, iinfo )
*
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZHPTRD(U)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 5 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
            ntest = 6
            CALL zupgtr( 'U', n, vp, tau, u, ldu, work, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZUPGTR(U)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 6 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do tests 5 and 6
*
            CALL zhpt21( 2, 'Upper', n, 1, ap, sd, se, u, ldu, vp, tau,
     $                   work, rwork, result( 5 ) )
            CALL zhpt21( 3, 'Upper', n, 1, ap, sd, se, u, ldu, vp, tau,
     $                   work, rwork, result( 6 ) )
*
*           Store the lower triangle of A in AP
*
            i = 0
            DO 140 jc = 1, n
               DO 130 jr = jc, n
                  i = i + 1
                  ap( i ) = a( jr, jc )
  130          CONTINUE
  140       CONTINUE
*
*           Call ZHPTRD and ZUPGTR to compute S and U from AP
*
            CALL zcopy( nap, ap, 1, vp, 1 )
*
            ntest = 7
            CALL zhptrd( 'L', n, vp, sd, se, tau, iinfo )
*
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZHPTRD(L)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 7 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
            ntest = 8
            CALL zupgtr( 'L', n, vp, tau, u, ldu, work, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZUPGTR(L)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 8 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
            CALL zhpt21( 2, 'Lower', n, 1, ap, sd, se, u, ldu, vp, tau,
     $                   work, rwork, result( 7 ) )
            CALL zhpt21( 3, 'Lower', n, 1, ap, sd, se, u, ldu, vp, tau,
     $                   work, rwork, result( 8 ) )
*
*           Call ZSTEQR to compute D1, D2, and Z, do tests.
*
*           Compute D1 and Z
*
            CALL dcopy( n, sd, 1, d1, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork, 1 )
            CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
            ntest = 9
            CALL zsteqr( 'V', n, d1, rwork, z, ldu, rwork( n+1 ),
     $                   iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEQR(V)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 9 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Compute D2
*
            CALL dcopy( n, sd, 1, d2, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork, 1 )
*
            ntest = 11
            CALL zsteqr( 'N', n, d2, rwork, work, ldu, rwork( n+1 ),
     $                   iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEQR(N)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 11 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Compute D3 (using PWK method)
*
            CALL dcopy( n, sd, 1, d3, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork, 1 )
*
            ntest = 12
            CALL dsterf( n, d3, rwork, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'DSTERF', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 12 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do Tests 9 and 10
*
            CALL zstt21( n, 0, sd, se, d1, dumma, z, ldu, work, rwork,
     $                   result( 9 ) )
*
*           Do Tests 11 and 12
*
            temp1 = zero
            temp2 = zero
            temp3 = zero
            temp4 = zero
*
            DO 150 j = 1, n
               temp1 = max( temp1, abs( d1( j ) ), abs( d2( j ) ) )
               temp2 = max( temp2, abs( d1( j )-d2( j ) ) )
               temp3 = max( temp3, abs( d1( j ) ), abs( d3( j ) ) )
               temp4 = max( temp4, abs( d1( j )-d3( j ) ) )
  150       CONTINUE
*
            result( 11 ) = temp2 / max( unfl, ulp*max( temp1, temp2 ) )
            result( 12 ) = temp4 / max( unfl, ulp*max( temp3, temp4 ) )
*
*           Do Test 13 -- Sturm Sequence Test of Eigenvalues
*                         Go up by factors of two until it succeeds
*
            ntest = 13
            temp1 = thresh*( half-ulp )
*
            DO 160 j = 0, log2ui
               CALL dstech( n, sd, se, d1, temp1, rwork, iinfo )
               IF( iinfo.EQ.0 )
     $            GO TO 170
               temp1 = temp1*two
  160       CONTINUE
*
  170       CONTINUE
            result( 13 ) = temp1
*
*           For positive definite matrices ( JTYPE.GT.15 ) call ZPTEQR
*           and do tests 14, 15, and 16 .
*
            IF( jtype.GT.15 ) THEN
*
*              Compute D4 and Z4
*
               CALL dcopy( n, sd, 1, d4, 1 )
               IF( n.GT.0 )
     $            CALL dcopy( n-1, se, 1, rwork, 1 )
               CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
               ntest = 14
               CALL zpteqr( 'V', n, d4, rwork, z, ldu, rwork( n+1 ),
     $                      iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9999 )'ZPTEQR(V)', iinfo, n,
     $               jtype, ioldsd
                  info = abs( iinfo )
                  IF( iinfo.LT.0 ) THEN
                     RETURN
                  ELSE
                     result( 14 ) = ulpinv
                     GO TO 280
                  END IF
               END IF
*
*              Do Tests 14 and 15
*
               CALL zstt21( n, 0, sd, se, d4, dumma, z, ldu, work,
     $                      rwork, result( 14 ) )
*
*              Compute D5
*
               CALL dcopy( n, sd, 1, d5, 1 )
               IF( n.GT.0 )
     $            CALL dcopy( n-1, se, 1, rwork, 1 )
*
               ntest = 16
               CALL zpteqr( 'N', n, d5, rwork, z, ldu, rwork( n+1 ),
     $                      iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9999 )'ZPTEQR(N)', iinfo, n,
     $               jtype, ioldsd
                  info = abs( iinfo )
                  IF( iinfo.LT.0 ) THEN
                     RETURN
                  ELSE
                     result( 16 ) = ulpinv
                     GO TO 280
                  END IF
               END IF
*
*              Do Test 16
*
               temp1 = zero
               temp2 = zero
               DO 180 j = 1, n
                  temp1 = max( temp1, abs( d4( j ) ), abs( d5( j ) ) )
                  temp2 = max( temp2, abs( d4( j )-d5( j ) ) )
  180          CONTINUE
*
               result( 16 ) = temp2 / max( unfl,
     $                        hun*ulp*max( temp1, temp2 ) )
            ELSE
               result( 14 ) = zero
               result( 15 ) = zero
               result( 16 ) = zero
            END IF
*
*           Call DSTEBZ with different options and do tests 17-18.
*
*              If S is positive definite and diagonally dominant,
*              ask for all eigenvalues with high relative accuracy.
*
            vl = zero
            vu = zero
            il = 0
            iu = 0
            IF( jtype.EQ.21 ) THEN
               ntest = 17
               abstol = unfl + unfl
               CALL dstebz( 'A', 'E', n, vl, vu, il, iu, abstol, sd, se,
     $                      m, nsplit, wr, iwork( 1 ), iwork( n+1 ),
     $                      rwork, iwork( 2*n+1 ), iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9999 )'DSTEBZ(A,rel)', iinfo, n,
     $               jtype, ioldsd
                  info = abs( iinfo )
                  IF( iinfo.LT.0 ) THEN
                     RETURN
                  ELSE
                     result( 17 ) = ulpinv
                     GO TO 280
                  END IF
               END IF
*
*              Do test 17
*
               temp2 = two*( two*n-one )*ulp*( one+eight*half**2 ) /
     $                 ( one-half )**4
*
               temp1 = zero
               DO 190 j = 1, n
                  temp1 = max( temp1, abs( d4( j )-wr( n-j+1 ) ) /
     $                    ( abstol+abs( d4( j ) ) ) )
  190          CONTINUE
*
               result( 17 ) = temp1 / temp2
            ELSE
               result( 17 ) = zero
            END IF
*
*           Now ask for all eigenvalues with high absolute accuracy.
*
            ntest = 18
            abstol = unfl + unfl
            CALL dstebz( 'A', 'E', n, vl, vu, il, iu, abstol, sd, se, m,
     $                   nsplit, wa1, iwork( 1 ), iwork( n+1 ), rwork,
     $                   iwork( 2*n+1 ), iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'DSTEBZ(A)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 18 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do test 18
*
            temp1 = zero
            temp2 = zero
            DO 200 j = 1, n
               temp1 = max( temp1, abs( d3( j ) ), abs( wa1( j ) ) )
               temp2 = max( temp2, abs( d3( j )-wa1( j ) ) )
  200       CONTINUE
*
            result( 18 ) = temp2 / max( unfl, ulp*max( temp1, temp2 ) )
*
*           Choose random values for IL and IU, and ask for the
*           IL-th through IU-th eigenvalues.
*
            ntest = 19
            IF( n.LE.1 ) THEN
               il = 1
               iu = n
            ELSE
               il = 1 + ( n-1 )*int( dlarnd( 1, iseed2 ) )
               iu = 1 + ( n-1 )*int( dlarnd( 1, iseed2 ) )
               IF( iu.LT.il ) THEN
                  itemp = iu
                  iu = il
                  il = itemp
               END IF
            END IF
*
            CALL dstebz( 'I', 'E', n, vl, vu, il, iu, abstol, sd, se,
     $                   m2, nsplit, wa2, iwork( 1 ), iwork( n+1 ),
     $                   rwork, iwork( 2*n+1 ), iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'DSTEBZ(I)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 19 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Determine the values VL and VU of the IL-th and IU-th
*           eigenvalues and ask for all eigenvalues in this range.
*
            IF( n.GT.0 ) THEN
               IF( il.NE.1 ) THEN
                  vl = wa1( il ) - max( half*( wa1( il )-wa1( il-1 ) ),
     $                 ulp*anorm, two*rtunfl )
               ELSE
                  vl = wa1( 1 ) - max( half*( wa1( n )-wa1( 1 ) ),
     $                 ulp*anorm, two*rtunfl )
               END IF
               IF( iu.NE.n ) THEN
                  vu = wa1( iu ) + max( half*( wa1( iu+1 )-wa1( iu ) ),
     $                 ulp*anorm, two*rtunfl )
               ELSE
                  vu = wa1( n ) + max( half*( wa1( n )-wa1( 1 ) ),
     $                 ulp*anorm, two*rtunfl )
               END IF
            ELSE
               vl = zero
               vu = one
            END IF
*
            CALL dstebz( 'V', 'E', n, vl, vu, il, iu, abstol, sd, se,
     $                   m3, nsplit, wa3, iwork( 1 ), iwork( n+1 ),
     $                   rwork, iwork( 2*n+1 ), iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'DSTEBZ(V)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 19 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
            IF( m3.EQ.0 .AND. n.NE.0 ) THEN
               result( 19 ) = ulpinv
               GO TO 280
            END IF
*
*           Do test 19
*
            temp1 = dsxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
            temp2 = dsxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
            IF( n.GT.0 ) THEN
               temp3 = max( abs( wa1( n ) ), abs( wa1( 1 ) ) )
            ELSE
               temp3 = zero
            END IF
*
            result( 19 ) = ( temp1+temp2 ) / max( unfl, temp3*ulp )
*
*           Call ZSTEIN to compute eigenvectors corresponding to
*           eigenvalues in WA1.  (First call DSTEBZ again, to make sure
*           it returns these eigenvalues in the correct order.)
*
            ntest = 21
            CALL dstebz( 'A', 'B', n, vl, vu, il, iu, abstol, sd, se, m,
     $                   nsplit, wa1, iwork( 1 ), iwork( n+1 ), rwork,
     $                   iwork( 2*n+1 ), iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'DSTEBZ(A,B)', iinfo, n,
     $            jtype, ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 20 ) = ulpinv
                  result( 21 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
            CALL zstein( n, sd, se, m, wa1, iwork( 1 ), iwork( n+1 ), z,
     $                   ldu, rwork, iwork( 2*n+1 ), iwork( 3*n+1 ),
     $                   iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEIN', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 20 ) = ulpinv
                  result( 21 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do tests 20 and 21
*
            CALL zstt21( n, 0, sd, se, wa1, dumma, z, ldu, work, rwork,
     $                   result( 20 ) )
*
*           Call ZSTEDC(I) to compute D1 and Z, do tests.
*
*           Compute D1 and Z
*
            inde = 1
            indrwk = inde + n
            CALL dcopy( n, sd, 1, d1, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork( inde ), 1 )
            CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
            ntest = 22
            CALL zstedc( 'I', n, d1, rwork( inde ), z, ldu, work, lwedc,
     $                   rwork( indrwk ), lrwedc, iwork, liwedc, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEDC(I)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 22 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do Tests 22 and 23
*
            CALL zstt21( n, 0, sd, se, d1, dumma, z, ldu, work, rwork,
     $                   result( 22 ) )
*
*           Call ZSTEDC(V) to compute D1 and Z, do tests.
*
*           Compute D1 and Z
*
            CALL dcopy( n, sd, 1, d1, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork( inde ), 1 )
            CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
            ntest = 24
            CALL zstedc( 'V', n, d1, rwork( inde ), z, ldu, work, lwedc,
     $                   rwork( indrwk ), lrwedc, iwork, liwedc, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEDC(V)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 24 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do Tests 24 and 25
*
            CALL zstt21( n, 0, sd, se, d1, dumma, z, ldu, work, rwork,
     $                   result( 24 ) )
*
*           Call ZSTEDC(N) to compute D2, do tests.
*
*           Compute D2
*
            CALL dcopy( n, sd, 1, d2, 1 )
            IF( n.GT.0 )
     $         CALL dcopy( n-1, se, 1, rwork( inde ), 1 )
            CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
            ntest = 26
            CALL zstedc( 'N', n, d2, rwork( inde ), z, ldu, work, lwedc,
     $                   rwork( indrwk ), lrwedc, iwork, liwedc, iinfo )
            IF( iinfo.NE.0 ) THEN
               WRITE( nounit, fmt = 9999 )'ZSTEDC(N)', iinfo, n, jtype,
     $            ioldsd
               info = abs( iinfo )
               IF( iinfo.LT.0 ) THEN
                  RETURN
               ELSE
                  result( 26 ) = ulpinv
                  GO TO 280
               END IF
            END IF
*
*           Do Test 26
*
            temp1 = zero
            temp2 = zero
*
            DO 210 j = 1, n
               temp1 = max( temp1, abs( d1( j ) ), abs( d2( j ) ) )
               temp2 = max( temp2, abs( d1( j )-d2( j ) ) )
  210       CONTINUE
*
            result( 26 ) = temp2 / max( unfl, ulp*max( temp1, temp2 ) )
*
*           Only test ZSTEMR if IEEE compliant
*
            IF( ilaenv( 10, 'ZSTEMR', 'VA', 1, 0, 0, 0 ).EQ.1 .AND.
     $          ilaenv( 11, 'ZSTEMR', 'VA', 1, 0, 0, 0 ).EQ.1 ) THEN
*
*           Call ZSTEMR, do test 27 (relative eigenvalue accuracy)
*
*              If S is positive definite and diagonally dominant,
*              ask for all eigenvalues with high relative accuracy.
*
               vl = zero
               vu = zero
               il = 0
               iu = 0
               IF( jtype.EQ.21 .AND. crel ) THEN
                  ntest = 27
                  abstol = unfl + unfl
                  CALL zstemr( 'V', 'A', n, sd, se, vl, vu, il, iu,
     $                         m, wr, z, ldu, n, iwork( 1 ), tryrac,
     $                         rwork, lrwork, iwork( 2*n+1 ), lwork-2*n,
     $                         iinfo )
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9999 )'ZSTEMR(V,A,rel)',
     $                  iinfo, n, jtype, ioldsd
                     info = abs( iinfo )
                     IF( iinfo.LT.0 ) THEN
                        RETURN
                     ELSE
                        result( 27 ) = ulpinv
                        GO TO 270
                     END IF
                  END IF
*
*              Do test 27
*
                  temp2 = two*( two*n-one )*ulp*( one+eight*half**2 ) /
     $                    ( one-half )**4
*
                  temp1 = zero
                  DO 220 j = 1, n
                     temp1 = max( temp1, abs( d4( j )-wr( n-j+1 ) ) /
     $                       ( abstol+abs( d4( j ) ) ) )
  220             CONTINUE
*
                  result( 27 ) = temp1 / temp2
*
                  il = 1 + ( n-1 )*int( dlarnd( 1, iseed2 ) )
                  iu = 1 + ( n-1 )*int( dlarnd( 1, iseed2 ) )
                  IF( iu.LT.il ) THEN
                     itemp = iu
                     iu = il
                     il = itemp
                  END IF
*
                  IF( crange ) THEN
                     ntest = 28
                     abstol = unfl + unfl
                     CALL zstemr( 'V', 'I', n, sd, se, vl, vu, il, iu,
     $                            m, wr, z, ldu, n, iwork( 1 ), tryrac,
     $                            rwork, lrwork, iwork( 2*n+1 ),
     $                            lwork-2*n, iinfo )
*
                     IF( iinfo.NE.0 ) THEN
                        WRITE( nounit, fmt = 9999 )'ZSTEMR(V,I,rel)',
     $                     iinfo, n, jtype, ioldsd
                        info = abs( iinfo )
                        IF( iinfo.LT.0 ) THEN
                           RETURN
                        ELSE
                           result( 28 ) = ulpinv
                           GO TO 270
                        END IF
                     END IF
*
*
*                 Do test 28
*
                     temp2 = two*( two*n-one )*ulp*
     $                       ( one+eight*half**2 ) / ( one-half )**4
*
                     temp1 = zero
                     DO 230 j = il, iu
                        temp1 = max( temp1, abs( wr( j-il+1 )-d4( n-j+
     $                          1 ) ) / ( abstol+abs( wr( j-il+1 ) ) ) )
  230                CONTINUE
*
                     result( 28 ) = temp1 / temp2
                  ELSE
                     result( 28 ) = zero
                  END IF
               ELSE
                  result( 27 ) = zero
                  result( 28 ) = zero
               END IF
*
*           Call ZSTEMR(V,I) to compute D1 and Z, do tests.
*
*           Compute D1 and Z
*
               CALL dcopy( n, sd, 1, d5, 1 )
               IF( n.GT.0 )
     $            CALL dcopy( n-1, se, 1, rwork, 1 )
               CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
               IF( crange ) THEN
                  ntest = 29
                  il = 1 + ( n-1 )*int( dlarnd( 1, iseed2 ) )
                  iu = 1 + ( n-1 )*int( dlarnd( 1, iseed2 ) )
                  IF( iu.LT.il ) THEN
                     itemp = iu
                     iu = il
                     il = itemp
                  END IF
                  CALL zstemr( 'V', 'I', n, d5, rwork, vl, vu, il, iu,
     $                         m, d1, z, ldu, n, iwork( 1 ), tryrac,
     $                         rwork( n+1 ), lrwork-n, iwork( 2*n+1 ),
     $                         liwork-2*n, iinfo )
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9999 )'ZSTEMR(V,I)', iinfo,
     $                  n, jtype, ioldsd
                     info = abs( iinfo )
                     IF( iinfo.LT.0 ) THEN
                        RETURN
                     ELSE
                        result( 29 ) = ulpinv
                        GO TO 280
                     END IF
                  END IF
*
*           Do Tests 29 and 30
*
*
*           Call ZSTEMR to compute D2, do tests.
*
*           Compute D2
*
                  CALL dcopy( n, sd, 1, d5, 1 )
                  IF( n.GT.0 )
     $               CALL dcopy( n-1, se, 1, rwork, 1 )
*
                  ntest = 31
                  CALL zstemr( 'N', 'I', n, d5, rwork, vl, vu, il, iu,
     $                         m, d2, z, ldu, n, iwork( 1 ), tryrac,
     $                         rwork( n+1 ), lrwork-n, iwork( 2*n+1 ),
     $                         liwork-2*n, iinfo )
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9999 )'ZSTEMR(N,I)', iinfo,
     $                  n, jtype, ioldsd
                     info = abs( iinfo )
                     IF( iinfo.LT.0 ) THEN
                        RETURN
                     ELSE
                        result( 31 ) = ulpinv
                        GO TO 280
                     END IF
                  END IF
*
*           Do Test 31
*
                  temp1 = zero
                  temp2 = zero
*
                  DO 240 j = 1, iu - il + 1
                     temp1 = max( temp1, abs( d1( j ) ),
     $                       abs( d2( j ) ) )
                     temp2 = max( temp2, abs( d1( j )-d2( j ) ) )
  240             CONTINUE
*
                  result( 31 ) = temp2 / max( unfl,
     $                           ulp*max( temp1, temp2 ) )
*
*
*           Call ZSTEMR(V,V) to compute D1 and Z, do tests.
*
*           Compute D1 and Z
*
                  CALL dcopy( n, sd, 1, d5, 1 )
                  IF( n.GT.0 )
     $               CALL dcopy( n-1, se, 1, rwork, 1 )
                  CALL zlaset( 'Full', n, n, czero, cone, z, ldu )
*
                  ntest = 32
*
                  IF( n.GT.0 ) THEN
                     IF( il.NE.1 ) THEN
                        vl = d2( il ) - max( half*
     $                       ( d2( il )-d2( il-1 ) ), ulp*anorm,
     $                       two*rtunfl )
                     ELSE
                        vl = d2( 1 ) - max( half*( d2( n )-d2( 1 ) ),
     $                       ulp*anorm, two*rtunfl )
                     END IF
                     IF( iu.NE.n ) THEN
                        vu = d2( iu ) + max( half*
     $                       ( d2( iu+1 )-d2( iu ) ), ulp*anorm,
     $                       two*rtunfl )
                     ELSE
                        vu = d2( n ) + max( half*( d2( n )-d2( 1 ) ),
     $                       ulp*anorm, two*rtunfl )
                     END IF
                  ELSE
                     vl = zero
                     vu = one
                  END IF
*
                  CALL zstemr( 'V', 'V', n, d5, rwork, vl, vu, il, iu,
     $                         m, d1, z, ldu, m, iwork( 1 ), tryrac,
     $                         rwork( n+1 ), lrwork-n, iwork( 2*n+1 ),
     $                         liwork-2*n, iinfo )
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9999 )'ZSTEMR(V,V)', iinfo,
     $                  n, jtype, ioldsd
                     info = abs( iinfo )
                     IF( iinfo.LT.0 ) THEN
                        RETURN
                     ELSE
                        result( 32 ) = ulpinv
                        GO TO 280
                     END IF
                  END IF
*
*           Do Tests 32 and 33
*
                  CALL zstt22( n, m, 0, sd, se, d1, dumma, z, ldu, work,
     $                         m, rwork, result( 32 ) )
*
*           Call ZSTEMR to compute D2, do tests.
*
*           Compute D2
*
                  CALL dcopy( n, sd, 1, d5, 1 )
                  IF( n.GT.0 )
     $               CALL dcopy( n-1, se, 1, rwork, 1 )
*
                  ntest = 34
                  CALL zstemr( 'N', 'V', n, d5, rwork, vl, vu, il, iu,
     $                         m, d2, z, ldu, n, iwork( 1 ), tryrac,
     $                         rwork( n+1 ), lrwork-n, iwork( 2*n+1 ),
     $                         liwork-2*n, iinfo )
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9999 )'ZSTEMR(N,V)', iinfo,
     $                  n, jtype, ioldsd
                     info = abs( iinfo )
                     IF( iinfo.LT.0 ) THEN
                        RETURN
                     ELSE
                        result( 34 ) = ulpinv
                        GO TO 280
                     END IF
                  END IF
*
*           Do Test 34
*
                  temp1 = zero
                  temp2 = zero
*
                  DO 250 j = 1, iu - il + 1
                     temp1 = max( temp1, abs( d1( j ) ),
     $                       abs( d2( j ) ) )
                     temp2 = max( temp2, abs( d1( j )-d2( j ) ) )
  250             CONTINUE
*
                  result( 34 ) = temp2 / max( unfl,
     $                           ulp*max( temp1, temp2 ) )
               ELSE
                  result( 29 ) = zero
                  result( 30 ) = zero
                  result( 31 ) = zero
                  result( 32 ) = zero
                  result( 33 ) = zero
                  result( 34 ) = zero
               END IF
*
*
*           Call ZSTEMR(V,A) to compute D1 and Z, do tests.
*
*           Compute D1 and Z
*
               CALL dcopy( n, sd, 1, d5, 1 )
               IF( n.GT.0 )
     $            CALL dcopy( n-1, se, 1, rwork, 1 )
*
               ntest = 35
*
               CALL zstemr( 'V', 'A', n, d5, rwork, vl, vu, il, iu,
     $                      m, d1, z, ldu, n, iwork( 1 ), tryrac,
     $                      rwork( n+1 ), lrwork-n, iwork( 2*n+1 ),
     $                      liwork-2*n, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9999 )'ZSTEMR(V,A)', iinfo, n,
     $               jtype, ioldsd
                  info = abs( iinfo )
                  IF( iinfo.LT.0 ) THEN
                     RETURN
                  ELSE
                     result( 35 ) = ulpinv
                     GO TO 280
                  END IF
               END IF
*
*           Do Tests 35 and 36
*
               CALL zstt22( n, m, 0, sd, se, d1, dumma, z, ldu, work, m,
     $                      rwork, result( 35 ) )
*
*           Call ZSTEMR to compute D2, do tests.
*
*           Compute D2
*
               CALL dcopy( n, sd, 1, d5, 1 )
               IF( n.GT.0 )
     $            CALL dcopy( n-1, se, 1, rwork, 1 )
*
               ntest = 37
               CALL zstemr( 'N', 'A', n, d5, rwork, vl, vu, il, iu,
     $                      m, d2, z, ldu, n, iwork( 1 ), tryrac,
     $                      rwork( n+1 ), lrwork-n, iwork( 2*n+1 ),
     $                      liwork-2*n, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9999 )'ZSTEMR(N,A)', iinfo, n,
     $               jtype, ioldsd
                  info = abs( iinfo )
                  IF( iinfo.LT.0 ) THEN
                     RETURN
                  ELSE
                     result( 37 ) = ulpinv
                     GO TO 280
                  END IF
               END IF
*
*           Do Test 34
*
               temp1 = zero
               temp2 = zero
*
               DO 260 j = 1, n
                  temp1 = max( temp1, abs( d1( j ) ), abs( d2( j ) ) )
                  temp2 = max( temp2, abs( d1( j )-d2( j ) ) )
  260          CONTINUE
*
               result( 37 ) = temp2 / max( unfl,
     $                        ulp*max( temp1, temp2 ) )
            END IF
  270       CONTINUE
  280       CONTINUE
            ntestt = ntestt + ntest
*
*           End of Loop -- Check for RESULT(j) > THRESH
*
*
*           Print out tests which fail.
*
            DO 290 jr = 1, ntest
               IF( result( jr ).GE.thresh ) THEN
*
*                 If this is the first test to fail,
*                 print a header to the data file.
*
                  IF( nerrs.EQ.0 ) THEN
                     WRITE( nounit, fmt = 9998 )'ZST'
                     WRITE( nounit, fmt = 9997 )
                     WRITE( nounit, fmt = 9996 )
                     WRITE( nounit, fmt = 9995 )'Hermitian'
                     WRITE( nounit, fmt = 9994 )
*
*                    Tests performed
*
                     WRITE( nounit, fmt = 9987 )
                  END IF
                  nerrs = nerrs + 1
                  IF( result( jr ).LT.10000.0d0 ) THEN
                     WRITE( nounit, fmt = 9989 )n, jtype, ioldsd, jr,
     $                  result( jr )
                  ELSE
                     WRITE( nounit, fmt = 9988 )n, jtype, ioldsd, jr,
     $                  result( jr )
                  END IF
               END IF
  290       CONTINUE
  300    CONTINUE
  310 CONTINUE
*
*     Summary
*
      CALL dlasum( 'ZST', nounit, nerrs, ntestt )
      RETURN
*
 9999 FORMAT( ' ZCHKST2STG: ', a, ' returned INFO=', i6, '.', / 9x,
     $   'N=', i6, ', JTYPE=', i6, ', ISEED=(', 3( i5, ',' ), i5, ')' )
*
 9998 FORMAT( / 1x, a3, ' -- Complex Hermitian eigenvalue problem' )
 9997 FORMAT( ' Matrix types (see ZCHKST2STG for details): ' )
*
 9996 FORMAT( / ' Special Matrices:',
     $      / '  1=Zero matrix.                        ',
     $      '  5=Diagonal: clustered entries.',
     $      / '  2=Identity matrix.                    ',
     $      '  6=Diagonal: large, evenly spaced.',
     $      / '  3=Diagonal: evenly spaced entries.    ',
     $      '  7=Diagonal: small, evenly spaced.',
     $      / '  4=Diagonal: geometr. spaced entries.' )
 9995 FORMAT( ' Dense ', a, ' Matrices:',
     $      / '  8=Evenly spaced eigenvals.            ',
     $      ' 12=Small, evenly spaced eigenvals.',
     $      / '  9=Geometrically spaced eigenvals.     ',
     $      ' 13=Matrix with random O(1) entries.',
     $      / ' 10=Clustered eigenvalues.              ',
     $      ' 14=Matrix with large random entries.',
     $      / ' 11=Large, evenly spaced eigenvals.     ',
     $      ' 15=Matrix with small random entries.' )
 9994 FORMAT( ' 16=Positive definite, evenly spaced eigenvalues',
     $      / ' 17=Positive definite, geometrically spaced eigenvlaues',
     $      / ' 18=Positive definite, clustered eigenvalues',
     $      / ' 19=Positive definite, small evenly spaced eigenvalues',
     $      / ' 20=Positive definite, large evenly spaced eigenvalues',
     $      / ' 21=Diagonally dominant tridiagonal, geometrically',
     $      ' spaced eigenvalues' )
*
 9989 FORMAT( ' Matrix order=', i5, ', type=', i2, ', seed=',
     $      4( i4, ',' ), ' result ', i3, ' is', 0p, f8.2 )
 9988 FORMAT( ' Matrix order=', i5, ', type=', i2, ', seed=',
     $      4( i4, ',' ), ' result ', i3, ' is', 1p, d10.3 )
*
 9987 FORMAT( / 'Test performed:  see ZCHKST2STG for details.', / )
*     End of ZCHKST2STG
*
      END