LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ sdrvst()

subroutine sdrvst ( integer  NSIZES,
integer, dimension( * )  NN,
integer  NTYPES,
logical, dimension( * )  DOTYPE,
integer, dimension( 4 )  ISEED,
real  THRESH,
integer  NOUNIT,
real, dimension( lda, * )  A,
integer  LDA,
real, dimension( * )  D1,
real, dimension( * )  D2,
real, dimension( * )  D3,
real, dimension( * )  D4,
real, dimension( * )  EVEIGS,
real, dimension( * )  WA1,
real, dimension( * )  WA2,
real, dimension( * )  WA3,
real, dimension( ldu, * )  U,
integer  LDU,
real, dimension( ldu, * )  V,
real, dimension( * )  TAU,
real, dimension( ldu, * )  Z,
real, dimension( * )  WORK,
integer  LWORK,
integer, dimension( * )  IWORK,
integer  LIWORK,
real, dimension( * )  RESULT,
integer  INFO 
)

SDRVST

Purpose:
      SDRVST  checks the symmetric eigenvalue problem drivers.

              SSTEV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric tridiagonal matrix.

              SSTEVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric tridiagonal matrix.

              SSTEVR computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric tridiagonal matrix
              using the Relatively Robust Representation where it can.

              SSYEV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix.

              SSYEVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix.

              SSYEVR computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix
              using the Relatively Robust Representation where it can.

              SSPEV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix in packed
              storage.

              SSPEVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix in packed
              storage.

              SSBEV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric band matrix.

              SSBEVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric band matrix.

              SSYEVD computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix using
              a divide and conquer algorithm.

              SSPEVD computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric matrix in packed
              storage, using a divide and conquer algorithm.

              SSBEVD computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric band matrix,
              using a divide and conquer algorithm.

      When SDRVST 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 appropriate drivers.  For each matrix and each
      driver routine called, the following tests will be performed:

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

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

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

      where Z is the matrix of eigenvectors returned when the
      eigenvector option is given and D1 and D2 are the eigenvalues
      returned with and without the eigenvector option.

      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 eigenvalues
           1, ..., ULP  and random signs.
           (ULP = (first number larger than 1) - 1 )
      (4)  A diagonal matrix with geometrically spaced eigenvalues
           1, ..., ULP  and random signs.
      (5)  A diagonal matrix with "clustered" eigenvalues
           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 orthogonal 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 orthogonal 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 orthogonal 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) Symmetric 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) A band matrix with half bandwidth randomly chosen between
           0 and N-1, with evenly spaced eigenvalues 1, ..., ULP
           with random signs.
      (17) Same as (16), but multiplied by SQRT( overflow threshold )
      (18) Same as (16), but multiplied by SQRT( underflow threshold )
  NSIZES  INTEGER
          The number of sizes of matrices to use.  If it is zero,
          SDRVST does nothing.  It must be at least zero.
          Not modified.

  NN      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.
          Not modified.

  NTYPES  INTEGER
          The number of elements in DOTYPE.   If it is zero, SDRVST
          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. .
          Not modified.

  DOTYPE  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.
          Not modified.

  ISEED   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 SDRVST to continue the same random number
          sequence.
          Modified.

  THRESH  REAL
          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.
          Not modified.

  NOUNIT  INTEGER
          The FORTRAN unit number for printing out error messages
          (e.g., if a routine returns IINFO not equal to 0.)
          Not modified.

  A       REAL array, dimension (LDA , max(NN))
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually
          used.
          Modified.

  LDA     INTEGER
          The leading dimension of A.  It must be at
          least 1 and at least max( NN ).
          Not modified.

  D1      REAL array, dimension (max(NN))
          The eigenvalues of A, as computed by SSTEQR simlutaneously
          with Z.  On exit, the eigenvalues in D1 correspond with the
          matrix in A.
          Modified.

  D2      REAL array, dimension (max(NN))
          The eigenvalues of A, as computed by SSTEQR if Z is not
          computed.  On exit, the eigenvalues in D2 correspond with
          the matrix in A.
          Modified.

  D3      REAL array, dimension (max(NN))
          The eigenvalues of A, as computed by SSTERF.  On exit, the
          eigenvalues in D3 correspond with the matrix in A.
          Modified.

  D4      REAL array, dimension

  EVEIGS  REAL array, dimension (max(NN))
          The eigenvalues as computed by SSTEV('N', ... )
          (I reserve the right to change this to the output of
          whichever algorithm computes the most accurate eigenvalues).

  WA1     REAL array, dimension

  WA2     REAL array, dimension

  WA3     REAL array, dimension

  U       REAL array, dimension (LDU, max(NN))
          The orthogonal matrix computed by SSYTRD + SORGTR.
          Modified.

  LDU     INTEGER
          The leading dimension of U, Z, and V.  It must be at
          least 1 and at least max( NN ).
          Not modified.

  V       REAL array, dimension (LDU, max(NN))
          The Housholder vectors computed by SSYTRD in reducing A to
          tridiagonal form.
          Modified.

  TAU     REAL array, dimension (max(NN))
          The Householder factors computed by SSYTRD in reducing A
          to tridiagonal form.
          Modified.

  Z       REAL array, dimension (LDU, max(NN))
          The orthogonal matrix of eigenvectors computed by SSTEQR,
          SPTEQR, and SSTEIN.
          Modified.

  WORK    REAL array, dimension (LWORK)
          Workspace.
          Modified.

  LWORK   INTEGER
          The number of entries in WORK.  This must be at least
          1 + 4 * Nmax + 2 * Nmax * lg Nmax + 4 * Nmax**2
          where Nmax = max( NN(j), 2 ) and lg = log base 2.
          Not modified.

  IWORK   INTEGER array,
             dimension (6 + 6*Nmax + 5 * Nmax * lg Nmax )
          where Nmax = max( NN(j), 2 ) and lg = log base 2.
          Workspace.
          Modified.

  RESULT  REAL array, dimension (105)
          The values computed by the tests described above.
          The values are currently limited to 1/ulp, to avoid
          overflow.
          Modified.

  INFO    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) ).
          -16: LDU < 1 or LDU < NMAX.
          -21: LWORK too small.
          If  SLATMR, SLATMS, SSYTRD, SORGTR, SSTEQR, SSTERF,
              or SORMTR returns an error code, the
              absolute value of it is returned.
          Modified.

-----------------------------------------------------------------------

       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.
       NMAX            Largest value in NN.
       NMATS           The number of matrices generated so far.
       NERRS           The number of tests which have exceeded THRESH
                       so far (computed by SLAFTS).
       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) )

     The tests performed are:                 Routine tested
    1= | A - U S U' | / ( |A| n ulp )         SSTEV('V', ... )
    2= | I - U U' | / ( n ulp )               SSTEV('V', ... )
    3= |D(with Z) - D(w/o Z)| / (|D| ulp)     SSTEV('N', ... )
    4= | A - U S U' | / ( |A| n ulp )         SSTEVX('V','A', ... )
    5= | I - U U' | / ( n ulp )               SSTEVX('V','A', ... )
    6= |D(with Z) - EVEIGS| / (|D| ulp)       SSTEVX('N','A', ... )
    7= | A - U S U' | / ( |A| n ulp )         SSTEVR('V','A', ... )
    8= | I - U U' | / ( n ulp )               SSTEVR('V','A', ... )
    9= |D(with Z) - EVEIGS| / (|D| ulp)       SSTEVR('N','A', ... )
    10= | A - U S U' | / ( |A| n ulp )        SSTEVX('V','I', ... )
    11= | I - U U' | / ( n ulp )              SSTEVX('V','I', ... )
    12= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSTEVX('N','I', ... )
    13= | A - U S U' | / ( |A| n ulp )        SSTEVX('V','V', ... )
    14= | I - U U' | / ( n ulp )              SSTEVX('V','V', ... )
    15= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSTEVX('N','V', ... )
    16= | A - U S U' | / ( |A| n ulp )        SSTEVD('V', ... )
    17= | I - U U' | / ( n ulp )              SSTEVD('V', ... )
    18= |D(with Z) - EVEIGS| / (|D| ulp)      SSTEVD('N', ... )
    19= | A - U S U' | / ( |A| n ulp )        SSTEVR('V','I', ... )
    20= | I - U U' | / ( n ulp )              SSTEVR('V','I', ... )
    21= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSTEVR('N','I', ... )
    22= | A - U S U' | / ( |A| n ulp )        SSTEVR('V','V', ... )
    23= | I - U U' | / ( n ulp )              SSTEVR('V','V', ... )
    24= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSTEVR('N','V', ... )

    25= | A - U S U' | / ( |A| n ulp )        SSYEV('L','V', ... )
    26= | I - U U' | / ( n ulp )              SSYEV('L','V', ... )
    27= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEV('L','N', ... )
    28= | A - U S U' | / ( |A| n ulp )        SSYEVX('L','V','A', ... )
    29= | I - U U' | / ( n ulp )              SSYEVX('L','V','A', ... )
    30= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVX('L','N','A', ... )
    31= | A - U S U' | / ( |A| n ulp )        SSYEVX('L','V','I', ... )
    32= | I - U U' | / ( n ulp )              SSYEVX('L','V','I', ... )
    33= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVX('L','N','I', ... )
    34= | A - U S U' | / ( |A| n ulp )        SSYEVX('L','V','V', ... )
    35= | I - U U' | / ( n ulp )              SSYEVX('L','V','V', ... )
    36= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVX('L','N','V', ... )
    37= | A - U S U' | / ( |A| n ulp )        SSPEV('L','V', ... )
    38= | I - U U' | / ( n ulp )              SSPEV('L','V', ... )
    39= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEV('L','N', ... )
    40= | A - U S U' | / ( |A| n ulp )        SSPEVX('L','V','A', ... )
    41= | I - U U' | / ( n ulp )              SSPEVX('L','V','A', ... )
    42= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVX('L','N','A', ... )
    43= | A - U S U' | / ( |A| n ulp )        SSPEVX('L','V','I', ... )
    44= | I - U U' | / ( n ulp )              SSPEVX('L','V','I', ... )
    45= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVX('L','N','I', ... )
    46= | A - U S U' | / ( |A| n ulp )        SSPEVX('L','V','V', ... )
    47= | I - U U' | / ( n ulp )              SSPEVX('L','V','V', ... )
    48= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVX('L','N','V', ... )
    49= | A - U S U' | / ( |A| n ulp )        SSBEV('L','V', ... )
    50= | I - U U' | / ( n ulp )              SSBEV('L','V', ... )
    51= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEV('L','N', ... )
    52= | A - U S U' | / ( |A| n ulp )        SSBEVX('L','V','A', ... )
    53= | I - U U' | / ( n ulp )              SSBEVX('L','V','A', ... )
    54= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVX('L','N','A', ... )
    55= | A - U S U' | / ( |A| n ulp )        SSBEVX('L','V','I', ... )
    56= | I - U U' | / ( n ulp )              SSBEVX('L','V','I', ... )
    57= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVX('L','N','I', ... )
    58= | A - U S U' | / ( |A| n ulp )        SSBEVX('L','V','V', ... )
    59= | I - U U' | / ( n ulp )              SSBEVX('L','V','V', ... )
    60= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVX('L','N','V', ... )
    61= | A - U S U' | / ( |A| n ulp )        SSYEVD('L','V', ... )
    62= | I - U U' | / ( n ulp )              SSYEVD('L','V', ... )
    63= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVD('L','N', ... )
    64= | A - U S U' | / ( |A| n ulp )        SSPEVD('L','V', ... )
    65= | I - U U' | / ( n ulp )              SSPEVD('L','V', ... )
    66= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVD('L','N', ... )
    67= | A - U S U' | / ( |A| n ulp )        SSBEVD('L','V', ... )
    68= | I - U U' | / ( n ulp )              SSBEVD('L','V', ... )
    69= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVD('L','N', ... )
    70= | A - U S U' | / ( |A| n ulp )        SSYEVR('L','V','A', ... )
    71= | I - U U' | / ( n ulp )              SSYEVR('L','V','A', ... )
    72= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVR('L','N','A', ... )
    73= | A - U S U' | / ( |A| n ulp )        SSYEVR('L','V','I', ... )
    74= | I - U U' | / ( n ulp )              SSYEVR('L','V','I', ... )
    75= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVR('L','N','I', ... )
    76= | A - U S U' | / ( |A| n ulp )        SSYEVR('L','V','V', ... )
    77= | I - U U' | / ( n ulp )              SSYEVR('L','V','V', ... )
    78= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSYEVR('L','N','V', ... )

    Tests 25 through 78 are repeated (as tests 79 through 132)
    with UPLO='U'

    To be added in 1999

    79= | A - U S U' | / ( |A| n ulp )        SSPEVR('L','V','A', ... )
    80= | I - U U' | / ( n ulp )              SSPEVR('L','V','A', ... )
    81= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVR('L','N','A', ... )
    82= | A - U S U' | / ( |A| n ulp )        SSPEVR('L','V','I', ... )
    83= | I - U U' | / ( n ulp )              SSPEVR('L','V','I', ... )
    84= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVR('L','N','I', ... )
    85= | A - U S U' | / ( |A| n ulp )        SSPEVR('L','V','V', ... )
    86= | I - U U' | / ( n ulp )              SSPEVR('L','V','V', ... )
    87= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSPEVR('L','N','V', ... )
    88= | A - U S U' | / ( |A| n ulp )        SSBEVR('L','V','A', ... )
    89= | I - U U' | / ( n ulp )              SSBEVR('L','V','A', ... )
    90= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVR('L','N','A', ... )
    91= | A - U S U' | / ( |A| n ulp )        SSBEVR('L','V','I', ... )
    92= | I - U U' | / ( n ulp )              SSBEVR('L','V','I', ... )
    93= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVR('L','N','I', ... )
    94= | A - U S U' | / ( |A| n ulp )        SSBEVR('L','V','V', ... )
    95= | I - U U' | / ( n ulp )              SSBEVR('L','V','V', ... )
    96= |D(with Z) - D(w/o Z)| / (|D| ulp)    SSBEVR('L','N','V', ... )
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 449 of file sdrvst.f.

453 *
454 * -- LAPACK test routine --
455 * -- LAPACK is a software package provided by Univ. of Tennessee, --
456 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
457 *
458 * .. Scalar Arguments ..
459  INTEGER INFO, LDA, LDU, LIWORK, LWORK, NOUNIT, NSIZES,
460  $ NTYPES
461  REAL THRESH
462 * ..
463 * .. Array Arguments ..
464  LOGICAL DOTYPE( * )
465  INTEGER ISEED( 4 ), IWORK( * ), NN( * )
466  REAL A( LDA, * ), D1( * ), D2( * ), D3( * ),
467  $ D4( * ), EVEIGS( * ), RESULT( * ), TAU( * ),
468  $ U( LDU, * ), V( LDU, * ), WA1( * ), WA2( * ),
469  $ WA3( * ), WORK( * ), Z( LDU, * )
470 * ..
471 *
472 * =====================================================================
473 *
474 * .. Parameters ..
475  REAL ZERO, ONE, TWO, TEN
476  parameter( zero = 0.0e0, one = 1.0e0, two = 2.0e0,
477  $ ten = 10.0e0 )
478  REAL HALF
479  parameter( half = 0.5e0 )
480  INTEGER MAXTYP
481  parameter( maxtyp = 18 )
482 * ..
483 * .. Local Scalars ..
484  LOGICAL BADNN
485  CHARACTER UPLO
486  INTEGER I, IDIAG, IHBW, IINFO, IL, IMODE, INDX, IROW,
487  $ ITEMP, ITYPE, IU, IUPLO, J, J1, J2, JCOL,
488  $ JSIZE, JTYPE, KD, LGN, LIWEDC, LWEDC, M, M2,
489  $ M3, MTYPES, N, NERRS, NMATS, NMAX, NTEST,
490  $ NTESTT
491  REAL ABSTOL, ANINV, ANORM, COND, OVFL, RTOVFL,
492  $ RTUNFL, TEMP1, TEMP2, TEMP3, ULP, ULPINV, UNFL,
493  $ VL, VU
494 * ..
495 * .. Local Arrays ..
496  INTEGER IDUMMA( 1 ), IOLDSD( 4 ), ISEED2( 4 ),
497  $ ISEED3( 4 ), KMAGN( MAXTYP ), KMODE( MAXTYP ),
498  $ KTYPE( MAXTYP )
499 * ..
500 * .. External Functions ..
501  REAL SLAMCH, SLARND, SSXT1
502  EXTERNAL slamch, slarnd, ssxt1
503 * ..
504 * .. External Subroutines ..
505  EXTERNAL alasvm, slabad, slacpy, slafts, slaset, slatmr,
509  $ ssyt22, xerbla
510 * ..
511 * .. Scalars in Common ..
512  CHARACTER*32 SRNAMT
513 * ..
514 * .. Common blocks ..
515  COMMON / srnamc / srnamt
516 * ..
517 * .. Intrinsic Functions ..
518  INTRINSIC abs, int, log, max, min, real, sqrt
519 * ..
520 * .. Data statements ..
521  DATA ktype / 1, 2, 5*4, 5*5, 3*8, 3*9 /
522  DATA kmagn / 2*1, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 1,
523  $ 2, 3, 1, 2, 3 /
524  DATA kmode / 2*0, 4, 3, 1, 4, 4, 4, 3, 1, 4, 4, 0,
525  $ 0, 0, 4, 4, 4 /
526 * ..
527 * .. Executable Statements ..
528 *
529 * Keep ftrnchek happy
530 *
531  vl = zero
532  vu = zero
533 *
534 * 1) Check for errors
535 *
536  ntestt = 0
537  info = 0
538 *
539  badnn = .false.
540  nmax = 1
541  DO 10 j = 1, nsizes
542  nmax = max( nmax, nn( j ) )
543  IF( nn( j ).LT.0 )
544  $ badnn = .true.
545  10 CONTINUE
546 *
547 * Check for errors
548 *
549  IF( nsizes.LT.0 ) THEN
550  info = -1
551  ELSE IF( badnn ) THEN
552  info = -2
553  ELSE IF( ntypes.LT.0 ) THEN
554  info = -3
555  ELSE IF( lda.LT.nmax ) THEN
556  info = -9
557  ELSE IF( ldu.LT.nmax ) THEN
558  info = -16
559  ELSE IF( 2*max( 2, nmax )**2.GT.lwork ) THEN
560  info = -21
561  END IF
562 *
563  IF( info.NE.0 ) THEN
564  CALL xerbla( 'SDRVST', -info )
565  RETURN
566  END IF
567 *
568 * Quick return if nothing to do
569 *
570  IF( nsizes.EQ.0 .OR. ntypes.EQ.0 )
571  $ RETURN
572 *
573 * More Important constants
574 *
575  unfl = slamch( 'Safe minimum' )
576  ovfl = slamch( 'Overflow' )
577  CALL slabad( unfl, ovfl )
578  ulp = slamch( 'Epsilon' )*slamch( 'Base' )
579  ulpinv = one / ulp
580  rtunfl = sqrt( unfl )
581  rtovfl = sqrt( ovfl )
582 *
583 * Loop over sizes, types
584 *
585  DO 20 i = 1, 4
586  iseed2( i ) = iseed( i )
587  iseed3( i ) = iseed( i )
588  20 CONTINUE
589 *
590  nerrs = 0
591  nmats = 0
592 *
593 *
594  DO 1740 jsize = 1, nsizes
595  n = nn( jsize )
596  IF( n.GT.0 ) THEN
597  lgn = int( log( real( n ) ) / log( two ) )
598  IF( 2**lgn.LT.n )
599  $ lgn = lgn + 1
600  IF( 2**lgn.LT.n )
601  $ lgn = lgn + 1
602  lwedc = 1 + 4*n + 2*n*lgn + 4*n**2
603 c LIWEDC = 6 + 6*N + 5*N*LGN
604  liwedc = 3 + 5*n
605  ELSE
606  lwedc = 9
607 c LIWEDC = 12
608  liwedc = 8
609  END IF
610  aninv = one / real( max( 1, n ) )
611 *
612  IF( nsizes.NE.1 ) THEN
613  mtypes = min( maxtyp, ntypes )
614  ELSE
615  mtypes = min( maxtyp+1, ntypes )
616  END IF
617 *
618  DO 1730 jtype = 1, mtypes
619 *
620  IF( .NOT.dotype( jtype ) )
621  $ GO TO 1730
622  nmats = nmats + 1
623  ntest = 0
624 *
625  DO 30 j = 1, 4
626  ioldsd( j ) = iseed( j )
627  30 CONTINUE
628 *
629 * 2) Compute "A"
630 *
631 * Control parameters:
632 *
633 * KMAGN KMODE KTYPE
634 * =1 O(1) clustered 1 zero
635 * =2 large clustered 2 identity
636 * =3 small exponential (none)
637 * =4 arithmetic diagonal, (w/ eigenvalues)
638 * =5 random log symmetric, w/ eigenvalues
639 * =6 random (none)
640 * =7 random diagonal
641 * =8 random symmetric
642 * =9 band symmetric, w/ eigenvalues
643 *
644  IF( mtypes.GT.maxtyp )
645  $ GO TO 110
646 *
647  itype = ktype( jtype )
648  imode = kmode( jtype )
649 *
650 * Compute norm
651 *
652  GO TO ( 40, 50, 60 )kmagn( jtype )
653 *
654  40 CONTINUE
655  anorm = one
656  GO TO 70
657 *
658  50 CONTINUE
659  anorm = ( rtovfl*ulp )*aninv
660  GO TO 70
661 *
662  60 CONTINUE
663  anorm = rtunfl*n*ulpinv
664  GO TO 70
665 *
666  70 CONTINUE
667 *
668  CALL slaset( 'Full', lda, n, zero, zero, a, lda )
669  iinfo = 0
670  cond = ulpinv
671 *
672 * Special Matrices -- Identity & Jordan block
673 *
674 * Zero
675 *
676  IF( itype.EQ.1 ) THEN
677  iinfo = 0
678 *
679  ELSE IF( itype.EQ.2 ) THEN
680 *
681 * Identity
682 *
683  DO 80 jcol = 1, n
684  a( jcol, jcol ) = anorm
685  80 CONTINUE
686 *
687  ELSE IF( itype.EQ.4 ) THEN
688 *
689 * Diagonal Matrix, [Eigen]values Specified
690 *
691  CALL slatms( n, n, 'S', iseed, 'S', work, imode, cond,
692  $ anorm, 0, 0, 'N', a, lda, work( n+1 ),
693  $ iinfo )
694 *
695  ELSE IF( itype.EQ.5 ) THEN
696 *
697 * Symmetric, eigenvalues specified
698 *
699  CALL slatms( n, n, 'S', iseed, 'S', work, imode, cond,
700  $ anorm, n, n, 'N', a, lda, work( n+1 ),
701  $ iinfo )
702 *
703  ELSE IF( itype.EQ.7 ) THEN
704 *
705 * Diagonal, random eigenvalues
706 *
707  idumma( 1 ) = 1
708  CALL slatmr( n, n, 'S', iseed, 'S', work, 6, one, one,
709  $ 'T', 'N', work( n+1 ), 1, one,
710  $ work( 2*n+1 ), 1, one, 'N', idumma, 0, 0,
711  $ zero, anorm, 'NO', a, lda, iwork, iinfo )
712 *
713  ELSE IF( itype.EQ.8 ) THEN
714 *
715 * Symmetric, random eigenvalues
716 *
717  idumma( 1 ) = 1
718  CALL slatmr( n, n, 'S', iseed, 'S', work, 6, one, one,
719  $ 'T', 'N', work( n+1 ), 1, one,
720  $ work( 2*n+1 ), 1, one, 'N', idumma, n, n,
721  $ zero, anorm, 'NO', a, lda, iwork, iinfo )
722 *
723  ELSE IF( itype.EQ.9 ) THEN
724 *
725 * Symmetric banded, eigenvalues specified
726 *
727  ihbw = int( ( n-1 )*slarnd( 1, iseed3 ) )
728  CALL slatms( n, n, 'S', iseed, 'S', work, imode, cond,
729  $ anorm, ihbw, ihbw, 'Z', u, ldu, work( n+1 ),
730  $ iinfo )
731 *
732 * Store as dense matrix for most routines.
733 *
734  CALL slaset( 'Full', lda, n, zero, zero, a, lda )
735  DO 100 idiag = -ihbw, ihbw
736  irow = ihbw - idiag + 1
737  j1 = max( 1, idiag+1 )
738  j2 = min( n, n+idiag )
739  DO 90 j = j1, j2
740  i = j - idiag
741  a( i, j ) = u( irow, j )
742  90 CONTINUE
743  100 CONTINUE
744  ELSE
745  iinfo = 1
746  END IF
747 *
748  IF( iinfo.NE.0 ) THEN
749  WRITE( nounit, fmt = 9999 )'Generator', iinfo, n, jtype,
750  $ ioldsd
751  info = abs( iinfo )
752  RETURN
753  END IF
754 *
755  110 CONTINUE
756 *
757  abstol = unfl + unfl
758  IF( n.LE.1 ) THEN
759  il = 1
760  iu = n
761  ELSE
762  il = 1 + int( ( n-1 )*slarnd( 1, iseed2 ) )
763  iu = 1 + int( ( n-1 )*slarnd( 1, iseed2 ) )
764  IF( il.GT.iu ) THEN
765  itemp = il
766  il = iu
767  iu = itemp
768  END IF
769  END IF
770 *
771 * 3) If matrix is tridiagonal, call SSTEV and SSTEVX.
772 *
773  IF( jtype.LE.7 ) THEN
774  ntest = 1
775  DO 120 i = 1, n
776  d1( i ) = real( a( i, i ) )
777  120 CONTINUE
778  DO 130 i = 1, n - 1
779  d2( i ) = real( a( i+1, i ) )
780  130 CONTINUE
781  srnamt = 'SSTEV'
782  CALL sstev( 'V', n, d1, d2, z, ldu, work, iinfo )
783  IF( iinfo.NE.0 ) THEN
784  WRITE( nounit, fmt = 9999 )'SSTEV(V)', iinfo, n,
785  $ jtype, ioldsd
786  info = abs( iinfo )
787  IF( iinfo.LT.0 ) THEN
788  RETURN
789  ELSE
790  result( 1 ) = ulpinv
791  result( 2 ) = ulpinv
792  result( 3 ) = ulpinv
793  GO TO 180
794  END IF
795  END IF
796 *
797 * Do tests 1 and 2.
798 *
799  DO 140 i = 1, n
800  d3( i ) = real( a( i, i ) )
801  140 CONTINUE
802  DO 150 i = 1, n - 1
803  d4( i ) = real( a( i+1, i ) )
804  150 CONTINUE
805  CALL sstt21( n, 0, d3, d4, d1, d2, z, ldu, work,
806  $ result( 1 ) )
807 *
808  ntest = 3
809  DO 160 i = 1, n - 1
810  d4( i ) = real( a( i+1, i ) )
811  160 CONTINUE
812  srnamt = 'SSTEV'
813  CALL sstev( 'N', n, d3, d4, z, ldu, work, iinfo )
814  IF( iinfo.NE.0 ) THEN
815  WRITE( nounit, fmt = 9999 )'SSTEV(N)', iinfo, n,
816  $ jtype, ioldsd
817  info = abs( iinfo )
818  IF( iinfo.LT.0 ) THEN
819  RETURN
820  ELSE
821  result( 3 ) = ulpinv
822  GO TO 180
823  END IF
824  END IF
825 *
826 * Do test 3.
827 *
828  temp1 = zero
829  temp2 = zero
830  DO 170 j = 1, n
831  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
832  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
833  170 CONTINUE
834  result( 3 ) = temp2 / max( unfl,
835  $ ulp*max( temp1, temp2 ) )
836 *
837  180 CONTINUE
838 *
839  ntest = 4
840  DO 190 i = 1, n
841  eveigs( i ) = d3( i )
842  d1( i ) = real( a( i, i ) )
843  190 CONTINUE
844  DO 200 i = 1, n - 1
845  d2( i ) = real( a( i+1, i ) )
846  200 CONTINUE
847  srnamt = 'SSTEVX'
848  CALL sstevx( 'V', 'A', n, d1, d2, vl, vu, il, iu, abstol,
849  $ m, wa1, z, ldu, work, iwork, iwork( 5*n+1 ),
850  $ iinfo )
851  IF( iinfo.NE.0 ) THEN
852  WRITE( nounit, fmt = 9999 )'SSTEVX(V,A)', iinfo, n,
853  $ jtype, ioldsd
854  info = abs( iinfo )
855  IF( iinfo.LT.0 ) THEN
856  RETURN
857  ELSE
858  result( 4 ) = ulpinv
859  result( 5 ) = ulpinv
860  result( 6 ) = ulpinv
861  GO TO 250
862  END IF
863  END IF
864  IF( n.GT.0 ) THEN
865  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
866  ELSE
867  temp3 = zero
868  END IF
869 *
870 * Do tests 4 and 5.
871 *
872  DO 210 i = 1, n
873  d3( i ) = real( a( i, i ) )
874  210 CONTINUE
875  DO 220 i = 1, n - 1
876  d4( i ) = real( a( i+1, i ) )
877  220 CONTINUE
878  CALL sstt21( n, 0, d3, d4, wa1, d2, z, ldu, work,
879  $ result( 4 ) )
880 *
881  ntest = 6
882  DO 230 i = 1, n - 1
883  d4( i ) = real( a( i+1, i ) )
884  230 CONTINUE
885  srnamt = 'SSTEVX'
886  CALL sstevx( 'N', 'A', n, d3, d4, vl, vu, il, iu, abstol,
887  $ m2, wa2, z, ldu, work, iwork,
888  $ iwork( 5*n+1 ), iinfo )
889  IF( iinfo.NE.0 ) THEN
890  WRITE( nounit, fmt = 9999 )'SSTEVX(N,A)', iinfo, n,
891  $ jtype, ioldsd
892  info = abs( iinfo )
893  IF( iinfo.LT.0 ) THEN
894  RETURN
895  ELSE
896  result( 6 ) = ulpinv
897  GO TO 250
898  END IF
899  END IF
900 *
901 * Do test 6.
902 *
903  temp1 = zero
904  temp2 = zero
905  DO 240 j = 1, n
906  temp1 = max( temp1, abs( wa2( j ) ),
907  $ abs( eveigs( j ) ) )
908  temp2 = max( temp2, abs( wa2( j )-eveigs( j ) ) )
909  240 CONTINUE
910  result( 6 ) = temp2 / max( unfl,
911  $ ulp*max( temp1, temp2 ) )
912 *
913  250 CONTINUE
914 *
915  ntest = 7
916  DO 260 i = 1, n
917  d1( i ) = real( a( i, i ) )
918  260 CONTINUE
919  DO 270 i = 1, n - 1
920  d2( i ) = real( a( i+1, i ) )
921  270 CONTINUE
922  srnamt = 'SSTEVR'
923  CALL sstevr( 'V', 'A', n, d1, d2, vl, vu, il, iu, abstol,
924  $ m, wa1, z, ldu, iwork, work, lwork,
925  $ iwork(2*n+1), liwork-2*n, iinfo )
926  IF( iinfo.NE.0 ) THEN
927  WRITE( nounit, fmt = 9999 )'SSTEVR(V,A)', iinfo, n,
928  $ jtype, ioldsd
929  info = abs( iinfo )
930  IF( iinfo.LT.0 ) THEN
931  RETURN
932  ELSE
933  result( 7 ) = ulpinv
934  result( 8 ) = ulpinv
935  GO TO 320
936  END IF
937  END IF
938  IF( n.GT.0 ) THEN
939  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
940  ELSE
941  temp3 = zero
942  END IF
943 *
944 * Do tests 7 and 8.
945 *
946  DO 280 i = 1, n
947  d3( i ) = real( a( i, i ) )
948  280 CONTINUE
949  DO 290 i = 1, n - 1
950  d4( i ) = real( a( i+1, i ) )
951  290 CONTINUE
952  CALL sstt21( n, 0, d3, d4, wa1, d2, z, ldu, work,
953  $ result( 7 ) )
954 *
955  ntest = 9
956  DO 300 i = 1, n - 1
957  d4( i ) = real( a( i+1, i ) )
958  300 CONTINUE
959  srnamt = 'SSTEVR'
960  CALL sstevr( 'N', 'A', n, d3, d4, vl, vu, il, iu, abstol,
961  $ m2, wa2, z, ldu, iwork, work, lwork,
962  $ iwork(2*n+1), liwork-2*n, iinfo )
963  IF( iinfo.NE.0 ) THEN
964  WRITE( nounit, fmt = 9999 )'SSTEVR(N,A)', iinfo, n,
965  $ jtype, ioldsd
966  info = abs( iinfo )
967  IF( iinfo.LT.0 ) THEN
968  RETURN
969  ELSE
970  result( 9 ) = ulpinv
971  GO TO 320
972  END IF
973  END IF
974 *
975 * Do test 9.
976 *
977  temp1 = zero
978  temp2 = zero
979  DO 310 j = 1, n
980  temp1 = max( temp1, abs( wa2( j ) ),
981  $ abs( eveigs( j ) ) )
982  temp2 = max( temp2, abs( wa2( j )-eveigs( j ) ) )
983  310 CONTINUE
984  result( 9 ) = temp2 / max( unfl,
985  $ ulp*max( temp1, temp2 ) )
986 *
987  320 CONTINUE
988 *
989 *
990  ntest = 10
991  DO 330 i = 1, n
992  d1( i ) = real( a( i, i ) )
993  330 CONTINUE
994  DO 340 i = 1, n - 1
995  d2( i ) = real( a( i+1, i ) )
996  340 CONTINUE
997  srnamt = 'SSTEVX'
998  CALL sstevx( 'V', 'I', n, d1, d2, vl, vu, il, iu, abstol,
999  $ m2, wa2, z, ldu, work, iwork,
1000  $ iwork( 5*n+1 ), iinfo )
1001  IF( iinfo.NE.0 ) THEN
1002  WRITE( nounit, fmt = 9999 )'SSTEVX(V,I)', iinfo, n,
1003  $ jtype, ioldsd
1004  info = abs( iinfo )
1005  IF( iinfo.LT.0 ) THEN
1006  RETURN
1007  ELSE
1008  result( 10 ) = ulpinv
1009  result( 11 ) = ulpinv
1010  result( 12 ) = ulpinv
1011  GO TO 380
1012  END IF
1013  END IF
1014 *
1015 * Do tests 10 and 11.
1016 *
1017  DO 350 i = 1, n
1018  d3( i ) = real( a( i, i ) )
1019  350 CONTINUE
1020  DO 360 i = 1, n - 1
1021  d4( i ) = real( a( i+1, i ) )
1022  360 CONTINUE
1023  CALL sstt22( n, m2, 0, d3, d4, wa2, d2, z, ldu, work,
1024  $ max( 1, m2 ), result( 10 ) )
1025 *
1026 *
1027  ntest = 12
1028  DO 370 i = 1, n - 1
1029  d4( i ) = real( a( i+1, i ) )
1030  370 CONTINUE
1031  srnamt = 'SSTEVX'
1032  CALL sstevx( 'N', 'I', n, d3, d4, vl, vu, il, iu, abstol,
1033  $ m3, wa3, z, ldu, work, iwork,
1034  $ iwork( 5*n+1 ), iinfo )
1035  IF( iinfo.NE.0 ) THEN
1036  WRITE( nounit, fmt = 9999 )'SSTEVX(N,I)', iinfo, n,
1037  $ jtype, ioldsd
1038  info = abs( iinfo )
1039  IF( iinfo.LT.0 ) THEN
1040  RETURN
1041  ELSE
1042  result( 12 ) = ulpinv
1043  GO TO 380
1044  END IF
1045  END IF
1046 *
1047 * Do test 12.
1048 *
1049  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1050  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1051  result( 12 ) = ( temp1+temp2 ) / max( unfl, ulp*temp3 )
1052 *
1053  380 CONTINUE
1054 *
1055  ntest = 12
1056  IF( n.GT.0 ) THEN
1057  IF( il.NE.1 ) THEN
1058  vl = wa1( il ) - max( half*
1059  $ ( wa1( il )-wa1( il-1 ) ), ten*ulp*temp3,
1060  $ ten*rtunfl )
1061  ELSE
1062  vl = wa1( 1 ) - max( half*( wa1( n )-wa1( 1 ) ),
1063  $ ten*ulp*temp3, ten*rtunfl )
1064  END IF
1065  IF( iu.NE.n ) THEN
1066  vu = wa1( iu ) + max( half*
1067  $ ( wa1( iu+1 )-wa1( iu ) ), ten*ulp*temp3,
1068  $ ten*rtunfl )
1069  ELSE
1070  vu = wa1( n ) + max( half*( wa1( n )-wa1( 1 ) ),
1071  $ ten*ulp*temp3, ten*rtunfl )
1072  END IF
1073  ELSE
1074  vl = zero
1075  vu = one
1076  END IF
1077 *
1078  DO 390 i = 1, n
1079  d1( i ) = real( a( i, i ) )
1080  390 CONTINUE
1081  DO 400 i = 1, n - 1
1082  d2( i ) = real( a( i+1, i ) )
1083  400 CONTINUE
1084  srnamt = 'SSTEVX'
1085  CALL sstevx( 'V', 'V', n, d1, d2, vl, vu, il, iu, abstol,
1086  $ m2, wa2, z, ldu, work, iwork,
1087  $ iwork( 5*n+1 ), iinfo )
1088  IF( iinfo.NE.0 ) THEN
1089  WRITE( nounit, fmt = 9999 )'SSTEVX(V,V)', iinfo, n,
1090  $ jtype, ioldsd
1091  info = abs( iinfo )
1092  IF( iinfo.LT.0 ) THEN
1093  RETURN
1094  ELSE
1095  result( 13 ) = ulpinv
1096  result( 14 ) = ulpinv
1097  result( 15 ) = ulpinv
1098  GO TO 440
1099  END IF
1100  END IF
1101 *
1102  IF( m2.EQ.0 .AND. n.GT.0 ) THEN
1103  result( 13 ) = ulpinv
1104  result( 14 ) = ulpinv
1105  result( 15 ) = ulpinv
1106  GO TO 440
1107  END IF
1108 *
1109 * Do tests 13 and 14.
1110 *
1111  DO 410 i = 1, n
1112  d3( i ) = real( a( i, i ) )
1113  410 CONTINUE
1114  DO 420 i = 1, n - 1
1115  d4( i ) = real( a( i+1, i ) )
1116  420 CONTINUE
1117  CALL sstt22( n, m2, 0, d3, d4, wa2, d2, z, ldu, work,
1118  $ max( 1, m2 ), result( 13 ) )
1119 *
1120  ntest = 15
1121  DO 430 i = 1, n - 1
1122  d4( i ) = real( a( i+1, i ) )
1123  430 CONTINUE
1124  srnamt = 'SSTEVX'
1125  CALL sstevx( 'N', 'V', n, d3, d4, vl, vu, il, iu, abstol,
1126  $ m3, wa3, z, ldu, work, iwork,
1127  $ iwork( 5*n+1 ), iinfo )
1128  IF( iinfo.NE.0 ) THEN
1129  WRITE( nounit, fmt = 9999 )'SSTEVX(N,V)', iinfo, n,
1130  $ jtype, ioldsd
1131  info = abs( iinfo )
1132  IF( iinfo.LT.0 ) THEN
1133  RETURN
1134  ELSE
1135  result( 15 ) = ulpinv
1136  GO TO 440
1137  END IF
1138  END IF
1139 *
1140 * Do test 15.
1141 *
1142  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1143  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1144  result( 15 ) = ( temp1+temp2 ) / max( unfl, temp3*ulp )
1145 *
1146  440 CONTINUE
1147 *
1148  ntest = 16
1149  DO 450 i = 1, n
1150  d1( i ) = real( a( i, i ) )
1151  450 CONTINUE
1152  DO 460 i = 1, n - 1
1153  d2( i ) = real( a( i+1, i ) )
1154  460 CONTINUE
1155  srnamt = 'SSTEVD'
1156  CALL sstevd( 'V', n, d1, d2, z, ldu, work, lwedc, iwork,
1157  $ liwedc, iinfo )
1158  IF( iinfo.NE.0 ) THEN
1159  WRITE( nounit, fmt = 9999 )'SSTEVD(V)', iinfo, n,
1160  $ jtype, ioldsd
1161  info = abs( iinfo )
1162  IF( iinfo.LT.0 ) THEN
1163  RETURN
1164  ELSE
1165  result( 16 ) = ulpinv
1166  result( 17 ) = ulpinv
1167  result( 18 ) = ulpinv
1168  GO TO 510
1169  END IF
1170  END IF
1171 *
1172 * Do tests 16 and 17.
1173 *
1174  DO 470 i = 1, n
1175  d3( i ) = real( a( i, i ) )
1176  470 CONTINUE
1177  DO 480 i = 1, n - 1
1178  d4( i ) = real( a( i+1, i ) )
1179  480 CONTINUE
1180  CALL sstt21( n, 0, d3, d4, d1, d2, z, ldu, work,
1181  $ result( 16 ) )
1182 *
1183  ntest = 18
1184  DO 490 i = 1, n - 1
1185  d4( i ) = real( a( i+1, i ) )
1186  490 CONTINUE
1187  srnamt = 'SSTEVD'
1188  CALL sstevd( 'N', n, d3, d4, z, ldu, work, lwedc, iwork,
1189  $ liwedc, iinfo )
1190  IF( iinfo.NE.0 ) THEN
1191  WRITE( nounit, fmt = 9999 )'SSTEVD(N)', iinfo, n,
1192  $ jtype, ioldsd
1193  info = abs( iinfo )
1194  IF( iinfo.LT.0 ) THEN
1195  RETURN
1196  ELSE
1197  result( 18 ) = ulpinv
1198  GO TO 510
1199  END IF
1200  END IF
1201 *
1202 * Do test 18.
1203 *
1204  temp1 = zero
1205  temp2 = zero
1206  DO 500 j = 1, n
1207  temp1 = max( temp1, abs( eveigs( j ) ),
1208  $ abs( d3( j ) ) )
1209  temp2 = max( temp2, abs( eveigs( j )-d3( j ) ) )
1210  500 CONTINUE
1211  result( 18 ) = temp2 / max( unfl,
1212  $ ulp*max( temp1, temp2 ) )
1213 *
1214  510 CONTINUE
1215 *
1216  ntest = 19
1217  DO 520 i = 1, n
1218  d1( i ) = real( a( i, i ) )
1219  520 CONTINUE
1220  DO 530 i = 1, n - 1
1221  d2( i ) = real( a( i+1, i ) )
1222  530 CONTINUE
1223  srnamt = 'SSTEVR'
1224  CALL sstevr( 'V', 'I', n, d1, d2, vl, vu, il, iu, abstol,
1225  $ m2, wa2, z, ldu, iwork, work, lwork,
1226  $ iwork(2*n+1), liwork-2*n, iinfo )
1227  IF( iinfo.NE.0 ) THEN
1228  WRITE( nounit, fmt = 9999 )'SSTEVR(V,I)', iinfo, n,
1229  $ jtype, ioldsd
1230  info = abs( iinfo )
1231  IF( iinfo.LT.0 ) THEN
1232  RETURN
1233  ELSE
1234  result( 19 ) = ulpinv
1235  result( 20 ) = ulpinv
1236  result( 21 ) = ulpinv
1237  GO TO 570
1238  END IF
1239  END IF
1240 *
1241 * DO tests 19 and 20.
1242 *
1243  DO 540 i = 1, n
1244  d3( i ) = real( a( i, i ) )
1245  540 CONTINUE
1246  DO 550 i = 1, n - 1
1247  d4( i ) = real( a( i+1, i ) )
1248  550 CONTINUE
1249  CALL sstt22( n, m2, 0, d3, d4, wa2, d2, z, ldu, work,
1250  $ max( 1, m2 ), result( 19 ) )
1251 *
1252 *
1253  ntest = 21
1254  DO 560 i = 1, n - 1
1255  d4( i ) = real( a( i+1, i ) )
1256  560 CONTINUE
1257  srnamt = 'SSTEVR'
1258  CALL sstevr( 'N', 'I', n, d3, d4, vl, vu, il, iu, abstol,
1259  $ m3, wa3, z, ldu, iwork, work, lwork,
1260  $ iwork(2*n+1), liwork-2*n, iinfo )
1261  IF( iinfo.NE.0 ) THEN
1262  WRITE( nounit, fmt = 9999 )'SSTEVR(N,I)', iinfo, n,
1263  $ jtype, ioldsd
1264  info = abs( iinfo )
1265  IF( iinfo.LT.0 ) THEN
1266  RETURN
1267  ELSE
1268  result( 21 ) = ulpinv
1269  GO TO 570
1270  END IF
1271  END IF
1272 *
1273 * Do test 21.
1274 *
1275  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1276  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1277  result( 21 ) = ( temp1+temp2 ) / max( unfl, ulp*temp3 )
1278 *
1279  570 CONTINUE
1280 *
1281  ntest = 21
1282  IF( n.GT.0 ) THEN
1283  IF( il.NE.1 ) THEN
1284  vl = wa1( il ) - max( half*
1285  $ ( wa1( il )-wa1( il-1 ) ), ten*ulp*temp3,
1286  $ ten*rtunfl )
1287  ELSE
1288  vl = wa1( 1 ) - max( half*( wa1( n )-wa1( 1 ) ),
1289  $ ten*ulp*temp3, ten*rtunfl )
1290  END IF
1291  IF( iu.NE.n ) THEN
1292  vu = wa1( iu ) + max( half*
1293  $ ( wa1( iu+1 )-wa1( iu ) ), ten*ulp*temp3,
1294  $ ten*rtunfl )
1295  ELSE
1296  vu = wa1( n ) + max( half*( wa1( n )-wa1( 1 ) ),
1297  $ ten*ulp*temp3, ten*rtunfl )
1298  END IF
1299  ELSE
1300  vl = zero
1301  vu = one
1302  END IF
1303 *
1304  DO 580 i = 1, n
1305  d1( i ) = real( a( i, i ) )
1306  580 CONTINUE
1307  DO 590 i = 1, n - 1
1308  d2( i ) = real( a( i+1, i ) )
1309  590 CONTINUE
1310  srnamt = 'SSTEVR'
1311  CALL sstevr( 'V', 'V', n, d1, d2, vl, vu, il, iu, abstol,
1312  $ m2, wa2, z, ldu, iwork, work, lwork,
1313  $ iwork(2*n+1), liwork-2*n, iinfo )
1314  IF( iinfo.NE.0 ) THEN
1315  WRITE( nounit, fmt = 9999 )'SSTEVR(V,V)', iinfo, n,
1316  $ jtype, ioldsd
1317  info = abs( iinfo )
1318  IF( iinfo.LT.0 ) THEN
1319  RETURN
1320  ELSE
1321  result( 22 ) = ulpinv
1322  result( 23 ) = ulpinv
1323  result( 24 ) = ulpinv
1324  GO TO 630
1325  END IF
1326  END IF
1327 *
1328  IF( m2.EQ.0 .AND. n.GT.0 ) THEN
1329  result( 22 ) = ulpinv
1330  result( 23 ) = ulpinv
1331  result( 24 ) = ulpinv
1332  GO TO 630
1333  END IF
1334 *
1335 * Do tests 22 and 23.
1336 *
1337  DO 600 i = 1, n
1338  d3( i ) = real( a( i, i ) )
1339  600 CONTINUE
1340  DO 610 i = 1, n - 1
1341  d4( i ) = real( a( i+1, i ) )
1342  610 CONTINUE
1343  CALL sstt22( n, m2, 0, d3, d4, wa2, d2, z, ldu, work,
1344  $ max( 1, m2 ), result( 22 ) )
1345 *
1346  ntest = 24
1347  DO 620 i = 1, n - 1
1348  d4( i ) = real( a( i+1, i ) )
1349  620 CONTINUE
1350  srnamt = 'SSTEVR'
1351  CALL sstevr( 'N', 'V', n, d3, d4, vl, vu, il, iu, abstol,
1352  $ m3, wa3, z, ldu, iwork, work, lwork,
1353  $ iwork(2*n+1), liwork-2*n, iinfo )
1354  IF( iinfo.NE.0 ) THEN
1355  WRITE( nounit, fmt = 9999 )'SSTEVR(N,V)', iinfo, n,
1356  $ jtype, ioldsd
1357  info = abs( iinfo )
1358  IF( iinfo.LT.0 ) THEN
1359  RETURN
1360  ELSE
1361  result( 24 ) = ulpinv
1362  GO TO 630
1363  END IF
1364  END IF
1365 *
1366 * Do test 24.
1367 *
1368  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1369  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1370  result( 24 ) = ( temp1+temp2 ) / max( unfl, temp3*ulp )
1371 *
1372  630 CONTINUE
1373 *
1374 *
1375 *
1376  ELSE
1377 *
1378  DO 640 i = 1, 24
1379  result( i ) = zero
1380  640 CONTINUE
1381  ntest = 24
1382  END IF
1383 *
1384 * Perform remaining tests storing upper or lower triangular
1385 * part of matrix.
1386 *
1387  DO 1720 iuplo = 0, 1
1388  IF( iuplo.EQ.0 ) THEN
1389  uplo = 'L'
1390  ELSE
1391  uplo = 'U'
1392  END IF
1393 *
1394 * 4) Call SSYEV and SSYEVX.
1395 *
1396  CALL slacpy( ' ', n, n, a, lda, v, ldu )
1397 *
1398  ntest = ntest + 1
1399  srnamt = 'SSYEV'
1400  CALL ssyev( 'V', uplo, n, a, ldu, d1, work, lwork,
1401  $ iinfo )
1402  IF( iinfo.NE.0 ) THEN
1403  WRITE( nounit, fmt = 9999 )'SSYEV(V,' // uplo // ')',
1404  $ iinfo, n, jtype, ioldsd
1405  info = abs( iinfo )
1406  IF( iinfo.LT.0 ) THEN
1407  RETURN
1408  ELSE
1409  result( ntest ) = ulpinv
1410  result( ntest+1 ) = ulpinv
1411  result( ntest+2 ) = ulpinv
1412  GO TO 660
1413  END IF
1414  END IF
1415 *
1416 * Do tests 25 and 26 (or +54)
1417 *
1418  CALL ssyt21( 1, uplo, n, 0, v, ldu, d1, d2, a, ldu, z,
1419  $ ldu, tau, work, result( ntest ) )
1420 *
1421  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1422 *
1423  ntest = ntest + 2
1424  srnamt = 'SSYEV'
1425  CALL ssyev( 'N', uplo, n, a, ldu, d3, work, lwork,
1426  $ iinfo )
1427  IF( iinfo.NE.0 ) THEN
1428  WRITE( nounit, fmt = 9999 )'SSYEV(N,' // uplo // ')',
1429  $ iinfo, n, jtype, ioldsd
1430  info = abs( iinfo )
1431  IF( iinfo.LT.0 ) THEN
1432  RETURN
1433  ELSE
1434  result( ntest ) = ulpinv
1435  GO TO 660
1436  END IF
1437  END IF
1438 *
1439 * Do test 27 (or +54)
1440 *
1441  temp1 = zero
1442  temp2 = zero
1443  DO 650 j = 1, n
1444  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
1445  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
1446  650 CONTINUE
1447  result( ntest ) = temp2 / max( unfl,
1448  $ ulp*max( temp1, temp2 ) )
1449 *
1450  660 CONTINUE
1451  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1452 *
1453  ntest = ntest + 1
1454 *
1455  IF( n.GT.0 ) THEN
1456  temp3 = max( abs( d1( 1 ) ), abs( d1( n ) ) )
1457  IF( il.NE.1 ) THEN
1458  vl = d1( il ) - max( half*( d1( il )-d1( il-1 ) ),
1459  $ ten*ulp*temp3, ten*rtunfl )
1460  ELSE IF( n.GT.0 ) THEN
1461  vl = d1( 1 ) - max( half*( d1( n )-d1( 1 ) ),
1462  $ ten*ulp*temp3, ten*rtunfl )
1463  END IF
1464  IF( iu.NE.n ) THEN
1465  vu = d1( iu ) + max( half*( d1( iu+1 )-d1( iu ) ),
1466  $ ten*ulp*temp3, ten*rtunfl )
1467  ELSE IF( n.GT.0 ) THEN
1468  vu = d1( n ) + max( half*( d1( n )-d1( 1 ) ),
1469  $ ten*ulp*temp3, ten*rtunfl )
1470  END IF
1471  ELSE
1472  temp3 = zero
1473  vl = zero
1474  vu = one
1475  END IF
1476 *
1477  srnamt = 'SSYEVX'
1478  CALL ssyevx( 'V', 'A', uplo, n, a, ldu, vl, vu, il, iu,
1479  $ abstol, m, wa1, z, ldu, work, lwork, iwork,
1480  $ iwork( 5*n+1 ), iinfo )
1481  IF( iinfo.NE.0 ) THEN
1482  WRITE( nounit, fmt = 9999 )'SSYEVX(V,A,' // uplo //
1483  $ ')', iinfo, n, jtype, ioldsd
1484  info = abs( iinfo )
1485  IF( iinfo.LT.0 ) THEN
1486  RETURN
1487  ELSE
1488  result( ntest ) = ulpinv
1489  result( ntest+1 ) = ulpinv
1490  result( ntest+2 ) = ulpinv
1491  GO TO 680
1492  END IF
1493  END IF
1494 *
1495 * Do tests 28 and 29 (or +54)
1496 *
1497  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1498 *
1499  CALL ssyt21( 1, uplo, n, 0, a, ldu, d1, d2, z, ldu, v,
1500  $ ldu, tau, work, result( ntest ) )
1501 *
1502  ntest = ntest + 2
1503  srnamt = 'SSYEVX'
1504  CALL ssyevx( 'N', 'A', uplo, n, a, ldu, vl, vu, il, iu,
1505  $ abstol, m2, wa2, z, ldu, work, lwork, iwork,
1506  $ iwork( 5*n+1 ), iinfo )
1507  IF( iinfo.NE.0 ) THEN
1508  WRITE( nounit, fmt = 9999 )'SSYEVX(N,A,' // uplo //
1509  $ ')', iinfo, n, jtype, ioldsd
1510  info = abs( iinfo )
1511  IF( iinfo.LT.0 ) THEN
1512  RETURN
1513  ELSE
1514  result( ntest ) = ulpinv
1515  GO TO 680
1516  END IF
1517  END IF
1518 *
1519 * Do test 30 (or +54)
1520 *
1521  temp1 = zero
1522  temp2 = zero
1523  DO 670 j = 1, n
1524  temp1 = max( temp1, abs( wa1( j ) ), abs( wa2( j ) ) )
1525  temp2 = max( temp2, abs( wa1( j )-wa2( j ) ) )
1526  670 CONTINUE
1527  result( ntest ) = temp2 / max( unfl,
1528  $ ulp*max( temp1, temp2 ) )
1529 *
1530  680 CONTINUE
1531 *
1532  ntest = ntest + 1
1533  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1534  srnamt = 'SSYEVX'
1535  CALL ssyevx( 'V', 'I', uplo, n, a, ldu, vl, vu, il, iu,
1536  $ abstol, m2, wa2, z, ldu, work, lwork, iwork,
1537  $ iwork( 5*n+1 ), iinfo )
1538  IF( iinfo.NE.0 ) THEN
1539  WRITE( nounit, fmt = 9999 )'SSYEVX(V,I,' // uplo //
1540  $ ')', iinfo, n, jtype, ioldsd
1541  info = abs( iinfo )
1542  IF( iinfo.LT.0 ) THEN
1543  RETURN
1544  ELSE
1545  result( ntest ) = ulpinv
1546  result( ntest+1 ) = ulpinv
1547  result( ntest+2 ) = ulpinv
1548  GO TO 690
1549  END IF
1550  END IF
1551 *
1552 * Do tests 31 and 32 (or +54)
1553 *
1554  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1555 *
1556  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
1557  $ v, ldu, tau, work, result( ntest ) )
1558 *
1559  ntest = ntest + 2
1560  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1561  srnamt = 'SSYEVX'
1562  CALL ssyevx( 'N', 'I', uplo, n, a, ldu, vl, vu, il, iu,
1563  $ abstol, m3, wa3, z, ldu, work, lwork, iwork,
1564  $ iwork( 5*n+1 ), iinfo )
1565  IF( iinfo.NE.0 ) THEN
1566  WRITE( nounit, fmt = 9999 )'SSYEVX(N,I,' // uplo //
1567  $ ')', iinfo, n, jtype, ioldsd
1568  info = abs( iinfo )
1569  IF( iinfo.LT.0 ) THEN
1570  RETURN
1571  ELSE
1572  result( ntest ) = ulpinv
1573  GO TO 690
1574  END IF
1575  END IF
1576 *
1577 * Do test 33 (or +54)
1578 *
1579  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1580  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1581  result( ntest ) = ( temp1+temp2 ) /
1582  $ max( unfl, ulp*temp3 )
1583  690 CONTINUE
1584 *
1585  ntest = ntest + 1
1586  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1587  srnamt = 'SSYEVX'
1588  CALL ssyevx( 'V', 'V', uplo, n, a, ldu, vl, vu, il, iu,
1589  $ abstol, m2, wa2, z, ldu, work, lwork, iwork,
1590  $ iwork( 5*n+1 ), iinfo )
1591  IF( iinfo.NE.0 ) THEN
1592  WRITE( nounit, fmt = 9999 )'SSYEVX(V,V,' // uplo //
1593  $ ')', iinfo, n, jtype, ioldsd
1594  info = abs( iinfo )
1595  IF( iinfo.LT.0 ) THEN
1596  RETURN
1597  ELSE
1598  result( ntest ) = ulpinv
1599  result( ntest+1 ) = ulpinv
1600  result( ntest+2 ) = ulpinv
1601  GO TO 700
1602  END IF
1603  END IF
1604 *
1605 * Do tests 34 and 35 (or +54)
1606 *
1607  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1608 *
1609  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
1610  $ v, ldu, tau, work, result( ntest ) )
1611 *
1612  ntest = ntest + 2
1613  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1614  srnamt = 'SSYEVX'
1615  CALL ssyevx( 'N', 'V', uplo, n, a, ldu, vl, vu, il, iu,
1616  $ abstol, m3, wa3, z, ldu, work, lwork, iwork,
1617  $ iwork( 5*n+1 ), iinfo )
1618  IF( iinfo.NE.0 ) THEN
1619  WRITE( nounit, fmt = 9999 )'SSYEVX(N,V,' // uplo //
1620  $ ')', iinfo, n, jtype, ioldsd
1621  info = abs( iinfo )
1622  IF( iinfo.LT.0 ) THEN
1623  RETURN
1624  ELSE
1625  result( ntest ) = ulpinv
1626  GO TO 700
1627  END IF
1628  END IF
1629 *
1630  IF( m3.EQ.0 .AND. n.GT.0 ) THEN
1631  result( ntest ) = ulpinv
1632  GO TO 700
1633  END IF
1634 *
1635 * Do test 36 (or +54)
1636 *
1637  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1638  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1639  IF( n.GT.0 ) THEN
1640  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
1641  ELSE
1642  temp3 = zero
1643  END IF
1644  result( ntest ) = ( temp1+temp2 ) /
1645  $ max( unfl, temp3*ulp )
1646 *
1647  700 CONTINUE
1648 *
1649 * 5) Call SSPEV and SSPEVX.
1650 *
1651  CALL slacpy( ' ', n, n, v, ldu, a, lda )
1652 *
1653 * Load array WORK with the upper or lower triangular
1654 * part of the matrix in packed form.
1655 *
1656  IF( iuplo.EQ.1 ) THEN
1657  indx = 1
1658  DO 720 j = 1, n
1659  DO 710 i = 1, j
1660  work( indx ) = a( i, j )
1661  indx = indx + 1
1662  710 CONTINUE
1663  720 CONTINUE
1664  ELSE
1665  indx = 1
1666  DO 740 j = 1, n
1667  DO 730 i = j, n
1668  work( indx ) = a( i, j )
1669  indx = indx + 1
1670  730 CONTINUE
1671  740 CONTINUE
1672  END IF
1673 *
1674  ntest = ntest + 1
1675  srnamt = 'SSPEV'
1676  CALL sspev( 'V', uplo, n, work, d1, z, ldu, v, iinfo )
1677  IF( iinfo.NE.0 ) THEN
1678  WRITE( nounit, fmt = 9999 )'SSPEV(V,' // uplo // ')',
1679  $ iinfo, n, jtype, ioldsd
1680  info = abs( iinfo )
1681  IF( iinfo.LT.0 ) THEN
1682  RETURN
1683  ELSE
1684  result( ntest ) = ulpinv
1685  result( ntest+1 ) = ulpinv
1686  result( ntest+2 ) = ulpinv
1687  GO TO 800
1688  END IF
1689  END IF
1690 *
1691 * Do tests 37 and 38 (or +54)
1692 *
1693  CALL ssyt21( 1, uplo, n, 0, a, lda, d1, d2, z, ldu, v,
1694  $ ldu, tau, work, result( ntest ) )
1695 *
1696  IF( iuplo.EQ.1 ) THEN
1697  indx = 1
1698  DO 760 j = 1, n
1699  DO 750 i = 1, j
1700  work( indx ) = a( i, j )
1701  indx = indx + 1
1702  750 CONTINUE
1703  760 CONTINUE
1704  ELSE
1705  indx = 1
1706  DO 780 j = 1, n
1707  DO 770 i = j, n
1708  work( indx ) = a( i, j )
1709  indx = indx + 1
1710  770 CONTINUE
1711  780 CONTINUE
1712  END IF
1713 *
1714  ntest = ntest + 2
1715  srnamt = 'SSPEV'
1716  CALL sspev( 'N', uplo, n, work, d3, z, ldu, v, iinfo )
1717  IF( iinfo.NE.0 ) THEN
1718  WRITE( nounit, fmt = 9999 )'SSPEV(N,' // uplo // ')',
1719  $ iinfo, n, jtype, ioldsd
1720  info = abs( iinfo )
1721  IF( iinfo.LT.0 ) THEN
1722  RETURN
1723  ELSE
1724  result( ntest ) = ulpinv
1725  GO TO 800
1726  END IF
1727  END IF
1728 *
1729 * Do test 39 (or +54)
1730 *
1731  temp1 = zero
1732  temp2 = zero
1733  DO 790 j = 1, n
1734  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
1735  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
1736  790 CONTINUE
1737  result( ntest ) = temp2 / max( unfl,
1738  $ ulp*max( temp1, temp2 ) )
1739 *
1740 * Load array WORK with the upper or lower triangular part
1741 * of the matrix in packed form.
1742 *
1743  800 CONTINUE
1744  IF( iuplo.EQ.1 ) THEN
1745  indx = 1
1746  DO 820 j = 1, n
1747  DO 810 i = 1, j
1748  work( indx ) = a( i, j )
1749  indx = indx + 1
1750  810 CONTINUE
1751  820 CONTINUE
1752  ELSE
1753  indx = 1
1754  DO 840 j = 1, n
1755  DO 830 i = j, n
1756  work( indx ) = a( i, j )
1757  indx = indx + 1
1758  830 CONTINUE
1759  840 CONTINUE
1760  END IF
1761 *
1762  ntest = ntest + 1
1763 *
1764  IF( n.GT.0 ) THEN
1765  temp3 = max( abs( d1( 1 ) ), abs( d1( n ) ) )
1766  IF( il.NE.1 ) THEN
1767  vl = d1( il ) - max( half*( d1( il )-d1( il-1 ) ),
1768  $ ten*ulp*temp3, ten*rtunfl )
1769  ELSE IF( n.GT.0 ) THEN
1770  vl = d1( 1 ) - max( half*( d1( n )-d1( 1 ) ),
1771  $ ten*ulp*temp3, ten*rtunfl )
1772  END IF
1773  IF( iu.NE.n ) THEN
1774  vu = d1( iu ) + max( half*( d1( iu+1 )-d1( iu ) ),
1775  $ ten*ulp*temp3, ten*rtunfl )
1776  ELSE IF( n.GT.0 ) THEN
1777  vu = d1( n ) + max( half*( d1( n )-d1( 1 ) ),
1778  $ ten*ulp*temp3, ten*rtunfl )
1779  END IF
1780  ELSE
1781  temp3 = zero
1782  vl = zero
1783  vu = one
1784  END IF
1785 *
1786  srnamt = 'SSPEVX'
1787  CALL sspevx( 'V', 'A', uplo, n, work, vl, vu, il, iu,
1788  $ abstol, m, wa1, z, ldu, v, iwork,
1789  $ iwork( 5*n+1 ), iinfo )
1790  IF( iinfo.NE.0 ) THEN
1791  WRITE( nounit, fmt = 9999 )'SSPEVX(V,A,' // uplo //
1792  $ ')', iinfo, n, jtype, ioldsd
1793  info = abs( iinfo )
1794  IF( iinfo.LT.0 ) THEN
1795  RETURN
1796  ELSE
1797  result( ntest ) = ulpinv
1798  result( ntest+1 ) = ulpinv
1799  result( ntest+2 ) = ulpinv
1800  GO TO 900
1801  END IF
1802  END IF
1803 *
1804 * Do tests 40 and 41 (or +54)
1805 *
1806  CALL ssyt21( 1, uplo, n, 0, a, ldu, wa1, d2, z, ldu, v,
1807  $ ldu, tau, work, result( ntest ) )
1808 *
1809  ntest = ntest + 2
1810 *
1811  IF( iuplo.EQ.1 ) THEN
1812  indx = 1
1813  DO 860 j = 1, n
1814  DO 850 i = 1, j
1815  work( indx ) = a( i, j )
1816  indx = indx + 1
1817  850 CONTINUE
1818  860 CONTINUE
1819  ELSE
1820  indx = 1
1821  DO 880 j = 1, n
1822  DO 870 i = j, n
1823  work( indx ) = a( i, j )
1824  indx = indx + 1
1825  870 CONTINUE
1826  880 CONTINUE
1827  END IF
1828 *
1829  srnamt = 'SSPEVX'
1830  CALL sspevx( 'N', 'A', uplo, n, work, vl, vu, il, iu,
1831  $ abstol, m2, wa2, z, ldu, v, iwork,
1832  $ iwork( 5*n+1 ), iinfo )
1833  IF( iinfo.NE.0 ) THEN
1834  WRITE( nounit, fmt = 9999 )'SSPEVX(N,A,' // uplo //
1835  $ ')', iinfo, n, jtype, ioldsd
1836  info = abs( iinfo )
1837  IF( iinfo.LT.0 ) THEN
1838  RETURN
1839  ELSE
1840  result( ntest ) = ulpinv
1841  GO TO 900
1842  END IF
1843  END IF
1844 *
1845 * Do test 42 (or +54)
1846 *
1847  temp1 = zero
1848  temp2 = zero
1849  DO 890 j = 1, n
1850  temp1 = max( temp1, abs( wa1( j ) ), abs( wa2( j ) ) )
1851  temp2 = max( temp2, abs( wa1( j )-wa2( j ) ) )
1852  890 CONTINUE
1853  result( ntest ) = temp2 / max( unfl,
1854  $ ulp*max( temp1, temp2 ) )
1855 *
1856  900 CONTINUE
1857  IF( iuplo.EQ.1 ) THEN
1858  indx = 1
1859  DO 920 j = 1, n
1860  DO 910 i = 1, j
1861  work( indx ) = a( i, j )
1862  indx = indx + 1
1863  910 CONTINUE
1864  920 CONTINUE
1865  ELSE
1866  indx = 1
1867  DO 940 j = 1, n
1868  DO 930 i = j, n
1869  work( indx ) = a( i, j )
1870  indx = indx + 1
1871  930 CONTINUE
1872  940 CONTINUE
1873  END IF
1874 *
1875  ntest = ntest + 1
1876 *
1877  srnamt = 'SSPEVX'
1878  CALL sspevx( 'V', 'I', uplo, n, work, vl, vu, il, iu,
1879  $ abstol, m2, wa2, z, ldu, v, iwork,
1880  $ iwork( 5*n+1 ), iinfo )
1881  IF( iinfo.NE.0 ) THEN
1882  WRITE( nounit, fmt = 9999 )'SSPEVX(V,I,' // uplo //
1883  $ ')', iinfo, n, jtype, ioldsd
1884  info = abs( iinfo )
1885  IF( iinfo.LT.0 ) THEN
1886  RETURN
1887  ELSE
1888  result( ntest ) = ulpinv
1889  result( ntest+1 ) = ulpinv
1890  result( ntest+2 ) = ulpinv
1891  GO TO 990
1892  END IF
1893  END IF
1894 *
1895 * Do tests 43 and 44 (or +54)
1896 *
1897  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
1898  $ v, ldu, tau, work, result( ntest ) )
1899 *
1900  ntest = ntest + 2
1901 *
1902  IF( iuplo.EQ.1 ) THEN
1903  indx = 1
1904  DO 960 j = 1, n
1905  DO 950 i = 1, j
1906  work( indx ) = a( i, j )
1907  indx = indx + 1
1908  950 CONTINUE
1909  960 CONTINUE
1910  ELSE
1911  indx = 1
1912  DO 980 j = 1, n
1913  DO 970 i = j, n
1914  work( indx ) = a( i, j )
1915  indx = indx + 1
1916  970 CONTINUE
1917  980 CONTINUE
1918  END IF
1919 *
1920  srnamt = 'SSPEVX'
1921  CALL sspevx( 'N', 'I', uplo, n, work, vl, vu, il, iu,
1922  $ abstol, m3, wa3, z, ldu, v, iwork,
1923  $ iwork( 5*n+1 ), iinfo )
1924  IF( iinfo.NE.0 ) THEN
1925  WRITE( nounit, fmt = 9999 )'SSPEVX(N,I,' // uplo //
1926  $ ')', iinfo, n, jtype, ioldsd
1927  info = abs( iinfo )
1928  IF( iinfo.LT.0 ) THEN
1929  RETURN
1930  ELSE
1931  result( ntest ) = ulpinv
1932  GO TO 990
1933  END IF
1934  END IF
1935 *
1936  IF( m3.EQ.0 .AND. n.GT.0 ) THEN
1937  result( ntest ) = ulpinv
1938  GO TO 990
1939  END IF
1940 *
1941 * Do test 45 (or +54)
1942 *
1943  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
1944  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
1945  IF( n.GT.0 ) THEN
1946  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
1947  ELSE
1948  temp3 = zero
1949  END IF
1950  result( ntest ) = ( temp1+temp2 ) /
1951  $ max( unfl, temp3*ulp )
1952 *
1953  990 CONTINUE
1954  IF( iuplo.EQ.1 ) THEN
1955  indx = 1
1956  DO 1010 j = 1, n
1957  DO 1000 i = 1, j
1958  work( indx ) = a( i, j )
1959  indx = indx + 1
1960  1000 CONTINUE
1961  1010 CONTINUE
1962  ELSE
1963  indx = 1
1964  DO 1030 j = 1, n
1965  DO 1020 i = j, n
1966  work( indx ) = a( i, j )
1967  indx = indx + 1
1968  1020 CONTINUE
1969  1030 CONTINUE
1970  END IF
1971 *
1972  ntest = ntest + 1
1973 *
1974  srnamt = 'SSPEVX'
1975  CALL sspevx( 'V', 'V', uplo, n, work, vl, vu, il, iu,
1976  $ abstol, m2, wa2, z, ldu, v, iwork,
1977  $ iwork( 5*n+1 ), iinfo )
1978  IF( iinfo.NE.0 ) THEN
1979  WRITE( nounit, fmt = 9999 )'SSPEVX(V,V,' // uplo //
1980  $ ')', iinfo, n, jtype, ioldsd
1981  info = abs( iinfo )
1982  IF( iinfo.LT.0 ) THEN
1983  RETURN
1984  ELSE
1985  result( ntest ) = ulpinv
1986  result( ntest+1 ) = ulpinv
1987  result( ntest+2 ) = ulpinv
1988  GO TO 1080
1989  END IF
1990  END IF
1991 *
1992 * Do tests 46 and 47 (or +54)
1993 *
1994  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
1995  $ v, ldu, tau, work, result( ntest ) )
1996 *
1997  ntest = ntest + 2
1998 *
1999  IF( iuplo.EQ.1 ) THEN
2000  indx = 1
2001  DO 1050 j = 1, n
2002  DO 1040 i = 1, j
2003  work( indx ) = a( i, j )
2004  indx = indx + 1
2005  1040 CONTINUE
2006  1050 CONTINUE
2007  ELSE
2008  indx = 1
2009  DO 1070 j = 1, n
2010  DO 1060 i = j, n
2011  work( indx ) = a( i, j )
2012  indx = indx + 1
2013  1060 CONTINUE
2014  1070 CONTINUE
2015  END IF
2016 *
2017  srnamt = 'SSPEVX'
2018  CALL sspevx( 'N', 'V', uplo, n, work, vl, vu, il, iu,
2019  $ abstol, m3, wa3, z, ldu, v, iwork,
2020  $ iwork( 5*n+1 ), iinfo )
2021  IF( iinfo.NE.0 ) THEN
2022  WRITE( nounit, fmt = 9999 )'SSPEVX(N,V,' // uplo //
2023  $ ')', iinfo, n, jtype, ioldsd
2024  info = abs( iinfo )
2025  IF( iinfo.LT.0 ) THEN
2026  RETURN
2027  ELSE
2028  result( ntest ) = ulpinv
2029  GO TO 1080
2030  END IF
2031  END IF
2032 *
2033  IF( m3.EQ.0 .AND. n.GT.0 ) THEN
2034  result( ntest ) = ulpinv
2035  GO TO 1080
2036  END IF
2037 *
2038 * Do test 48 (or +54)
2039 *
2040  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
2041  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
2042  IF( n.GT.0 ) THEN
2043  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
2044  ELSE
2045  temp3 = zero
2046  END IF
2047  result( ntest ) = ( temp1+temp2 ) /
2048  $ max( unfl, temp3*ulp )
2049 *
2050  1080 CONTINUE
2051 *
2052 * 6) Call SSBEV and SSBEVX.
2053 *
2054  IF( jtype.LE.7 ) THEN
2055  kd = 1
2056  ELSE IF( jtype.GE.8 .AND. jtype.LE.15 ) THEN
2057  kd = max( n-1, 0 )
2058  ELSE
2059  kd = ihbw
2060  END IF
2061 *
2062 * Load array V with the upper or lower triangular part
2063 * of the matrix in band form.
2064 *
2065  IF( iuplo.EQ.1 ) THEN
2066  DO 1100 j = 1, n
2067  DO 1090 i = max( 1, j-kd ), j
2068  v( kd+1+i-j, j ) = a( i, j )
2069  1090 CONTINUE
2070  1100 CONTINUE
2071  ELSE
2072  DO 1120 j = 1, n
2073  DO 1110 i = j, min( n, j+kd )
2074  v( 1+i-j, j ) = a( i, j )
2075  1110 CONTINUE
2076  1120 CONTINUE
2077  END IF
2078 *
2079  ntest = ntest + 1
2080  srnamt = 'SSBEV'
2081  CALL ssbev( 'V', uplo, n, kd, v, ldu, d1, z, ldu, work,
2082  $ iinfo )
2083  IF( iinfo.NE.0 ) THEN
2084  WRITE( nounit, fmt = 9999 )'SSBEV(V,' // uplo // ')',
2085  $ iinfo, n, jtype, ioldsd
2086  info = abs( iinfo )
2087  IF( iinfo.LT.0 ) THEN
2088  RETURN
2089  ELSE
2090  result( ntest ) = ulpinv
2091  result( ntest+1 ) = ulpinv
2092  result( ntest+2 ) = ulpinv
2093  GO TO 1180
2094  END IF
2095  END IF
2096 *
2097 * Do tests 49 and 50 (or ... )
2098 *
2099  CALL ssyt21( 1, uplo, n, 0, a, lda, d1, d2, z, ldu, v,
2100  $ ldu, tau, work, result( ntest ) )
2101 *
2102  IF( iuplo.EQ.1 ) THEN
2103  DO 1140 j = 1, n
2104  DO 1130 i = max( 1, j-kd ), j
2105  v( kd+1+i-j, j ) = a( i, j )
2106  1130 CONTINUE
2107  1140 CONTINUE
2108  ELSE
2109  DO 1160 j = 1, n
2110  DO 1150 i = j, min( n, j+kd )
2111  v( 1+i-j, j ) = a( i, j )
2112  1150 CONTINUE
2113  1160 CONTINUE
2114  END IF
2115 *
2116  ntest = ntest + 2
2117  srnamt = 'SSBEV'
2118  CALL ssbev( 'N', uplo, n, kd, v, ldu, d3, z, ldu, work,
2119  $ iinfo )
2120  IF( iinfo.NE.0 ) THEN
2121  WRITE( nounit, fmt = 9999 )'SSBEV(N,' // uplo // ')',
2122  $ iinfo, n, jtype, ioldsd
2123  info = abs( iinfo )
2124  IF( iinfo.LT.0 ) THEN
2125  RETURN
2126  ELSE
2127  result( ntest ) = ulpinv
2128  GO TO 1180
2129  END IF
2130  END IF
2131 *
2132 * Do test 51 (or +54)
2133 *
2134  temp1 = zero
2135  temp2 = zero
2136  DO 1170 j = 1, n
2137  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
2138  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
2139  1170 CONTINUE
2140  result( ntest ) = temp2 / max( unfl,
2141  $ ulp*max( temp1, temp2 ) )
2142 *
2143 * Load array V with the upper or lower triangular part
2144 * of the matrix in band form.
2145 *
2146  1180 CONTINUE
2147  IF( iuplo.EQ.1 ) THEN
2148  DO 1200 j = 1, n
2149  DO 1190 i = max( 1, j-kd ), j
2150  v( kd+1+i-j, j ) = a( i, j )
2151  1190 CONTINUE
2152  1200 CONTINUE
2153  ELSE
2154  DO 1220 j = 1, n
2155  DO 1210 i = j, min( n, j+kd )
2156  v( 1+i-j, j ) = a( i, j )
2157  1210 CONTINUE
2158  1220 CONTINUE
2159  END IF
2160 *
2161  ntest = ntest + 1
2162  srnamt = 'SSBEVX'
2163  CALL ssbevx( 'V', 'A', uplo, n, kd, v, ldu, u, ldu, vl,
2164  $ vu, il, iu, abstol, m, wa2, z, ldu, work,
2165  $ iwork, iwork( 5*n+1 ), iinfo )
2166  IF( iinfo.NE.0 ) THEN
2167  WRITE( nounit, fmt = 9999 )'SSBEVX(V,A,' // uplo //
2168  $ ')', iinfo, n, jtype, ioldsd
2169  info = abs( iinfo )
2170  IF( iinfo.LT.0 ) THEN
2171  RETURN
2172  ELSE
2173  result( ntest ) = ulpinv
2174  result( ntest+1 ) = ulpinv
2175  result( ntest+2 ) = ulpinv
2176  GO TO 1280
2177  END IF
2178  END IF
2179 *
2180 * Do tests 52 and 53 (or +54)
2181 *
2182  CALL ssyt21( 1, uplo, n, 0, a, ldu, wa2, d2, z, ldu, v,
2183  $ ldu, tau, work, result( ntest ) )
2184 *
2185  ntest = ntest + 2
2186 *
2187  IF( iuplo.EQ.1 ) THEN
2188  DO 1240 j = 1, n
2189  DO 1230 i = max( 1, j-kd ), j
2190  v( kd+1+i-j, j ) = a( i, j )
2191  1230 CONTINUE
2192  1240 CONTINUE
2193  ELSE
2194  DO 1260 j = 1, n
2195  DO 1250 i = j, min( n, j+kd )
2196  v( 1+i-j, j ) = a( i, j )
2197  1250 CONTINUE
2198  1260 CONTINUE
2199  END IF
2200 *
2201  srnamt = 'SSBEVX'
2202  CALL ssbevx( 'N', 'A', uplo, n, kd, v, ldu, u, ldu, vl,
2203  $ vu, il, iu, abstol, m3, wa3, z, ldu, work,
2204  $ iwork, iwork( 5*n+1 ), iinfo )
2205  IF( iinfo.NE.0 ) THEN
2206  WRITE( nounit, fmt = 9999 )'SSBEVX(N,A,' // uplo //
2207  $ ')', iinfo, n, jtype, ioldsd
2208  info = abs( iinfo )
2209  IF( iinfo.LT.0 ) THEN
2210  RETURN
2211  ELSE
2212  result( ntest ) = ulpinv
2213  GO TO 1280
2214  END IF
2215  END IF
2216 *
2217 * Do test 54 (or +54)
2218 *
2219  temp1 = zero
2220  temp2 = zero
2221  DO 1270 j = 1, n
2222  temp1 = max( temp1, abs( wa2( j ) ), abs( wa3( j ) ) )
2223  temp2 = max( temp2, abs( wa2( j )-wa3( j ) ) )
2224  1270 CONTINUE
2225  result( ntest ) = temp2 / max( unfl,
2226  $ ulp*max( temp1, temp2 ) )
2227 *
2228  1280 CONTINUE
2229  ntest = ntest + 1
2230  IF( iuplo.EQ.1 ) THEN
2231  DO 1300 j = 1, n
2232  DO 1290 i = max( 1, j-kd ), j
2233  v( kd+1+i-j, j ) = a( i, j )
2234  1290 CONTINUE
2235  1300 CONTINUE
2236  ELSE
2237  DO 1320 j = 1, n
2238  DO 1310 i = j, min( n, j+kd )
2239  v( 1+i-j, j ) = a( i, j )
2240  1310 CONTINUE
2241  1320 CONTINUE
2242  END IF
2243 *
2244  srnamt = 'SSBEVX'
2245  CALL ssbevx( 'V', 'I', uplo, n, kd, v, ldu, u, ldu, vl,
2246  $ vu, il, iu, abstol, m2, wa2, z, ldu, work,
2247  $ iwork, iwork( 5*n+1 ), iinfo )
2248  IF( iinfo.NE.0 ) THEN
2249  WRITE( nounit, fmt = 9999 )'SSBEVX(V,I,' // uplo //
2250  $ ')', iinfo, n, jtype, ioldsd
2251  info = abs( iinfo )
2252  IF( iinfo.LT.0 ) THEN
2253  RETURN
2254  ELSE
2255  result( ntest ) = ulpinv
2256  result( ntest+1 ) = ulpinv
2257  result( ntest+2 ) = ulpinv
2258  GO TO 1370
2259  END IF
2260  END IF
2261 *
2262 * Do tests 55 and 56 (or +54)
2263 *
2264  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
2265  $ v, ldu, tau, work, result( ntest ) )
2266 *
2267  ntest = ntest + 2
2268 *
2269  IF( iuplo.EQ.1 ) THEN
2270  DO 1340 j = 1, n
2271  DO 1330 i = max( 1, j-kd ), j
2272  v( kd+1+i-j, j ) = a( i, j )
2273  1330 CONTINUE
2274  1340 CONTINUE
2275  ELSE
2276  DO 1360 j = 1, n
2277  DO 1350 i = j, min( n, j+kd )
2278  v( 1+i-j, j ) = a( i, j )
2279  1350 CONTINUE
2280  1360 CONTINUE
2281  END IF
2282 *
2283  srnamt = 'SSBEVX'
2284  CALL ssbevx( 'N', 'I', uplo, n, kd, v, ldu, u, ldu, vl,
2285  $ vu, il, iu, abstol, m3, wa3, z, ldu, work,
2286  $ iwork, iwork( 5*n+1 ), iinfo )
2287  IF( iinfo.NE.0 ) THEN
2288  WRITE( nounit, fmt = 9999 )'SSBEVX(N,I,' // uplo //
2289  $ ')', iinfo, n, jtype, ioldsd
2290  info = abs( iinfo )
2291  IF( iinfo.LT.0 ) THEN
2292  RETURN
2293  ELSE
2294  result( ntest ) = ulpinv
2295  GO TO 1370
2296  END IF
2297  END IF
2298 *
2299 * Do test 57 (or +54)
2300 *
2301  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
2302  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
2303  IF( n.GT.0 ) THEN
2304  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
2305  ELSE
2306  temp3 = zero
2307  END IF
2308  result( ntest ) = ( temp1+temp2 ) /
2309  $ max( unfl, temp3*ulp )
2310 *
2311  1370 CONTINUE
2312  ntest = ntest + 1
2313  IF( iuplo.EQ.1 ) THEN
2314  DO 1390 j = 1, n
2315  DO 1380 i = max( 1, j-kd ), j
2316  v( kd+1+i-j, j ) = a( i, j )
2317  1380 CONTINUE
2318  1390 CONTINUE
2319  ELSE
2320  DO 1410 j = 1, n
2321  DO 1400 i = j, min( n, j+kd )
2322  v( 1+i-j, j ) = a( i, j )
2323  1400 CONTINUE
2324  1410 CONTINUE
2325  END IF
2326 *
2327  srnamt = 'SSBEVX'
2328  CALL ssbevx( 'V', 'V', uplo, n, kd, v, ldu, u, ldu, vl,
2329  $ vu, il, iu, abstol, m2, wa2, z, ldu, work,
2330  $ iwork, iwork( 5*n+1 ), iinfo )
2331  IF( iinfo.NE.0 ) THEN
2332  WRITE( nounit, fmt = 9999 )'SSBEVX(V,V,' // uplo //
2333  $ ')', iinfo, n, jtype, ioldsd
2334  info = abs( iinfo )
2335  IF( iinfo.LT.0 ) THEN
2336  RETURN
2337  ELSE
2338  result( ntest ) = ulpinv
2339  result( ntest+1 ) = ulpinv
2340  result( ntest+2 ) = ulpinv
2341  GO TO 1460
2342  END IF
2343  END IF
2344 *
2345 * Do tests 58 and 59 (or +54)
2346 *
2347  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
2348  $ v, ldu, tau, work, result( ntest ) )
2349 *
2350  ntest = ntest + 2
2351 *
2352  IF( iuplo.EQ.1 ) THEN
2353  DO 1430 j = 1, n
2354  DO 1420 i = max( 1, j-kd ), j
2355  v( kd+1+i-j, j ) = a( i, j )
2356  1420 CONTINUE
2357  1430 CONTINUE
2358  ELSE
2359  DO 1450 j = 1, n
2360  DO 1440 i = j, min( n, j+kd )
2361  v( 1+i-j, j ) = a( i, j )
2362  1440 CONTINUE
2363  1450 CONTINUE
2364  END IF
2365 *
2366  srnamt = 'SSBEVX'
2367  CALL ssbevx( 'N', 'V', uplo, n, kd, v, ldu, u, ldu, vl,
2368  $ vu, il, iu, abstol, m3, wa3, z, ldu, work,
2369  $ iwork, iwork( 5*n+1 ), iinfo )
2370  IF( iinfo.NE.0 ) THEN
2371  WRITE( nounit, fmt = 9999 )'SSBEVX(N,V,' // uplo //
2372  $ ')', iinfo, n, jtype, ioldsd
2373  info = abs( iinfo )
2374  IF( iinfo.LT.0 ) THEN
2375  RETURN
2376  ELSE
2377  result( ntest ) = ulpinv
2378  GO TO 1460
2379  END IF
2380  END IF
2381 *
2382  IF( m3.EQ.0 .AND. n.GT.0 ) THEN
2383  result( ntest ) = ulpinv
2384  GO TO 1460
2385  END IF
2386 *
2387 * Do test 60 (or +54)
2388 *
2389  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
2390  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
2391  IF( n.GT.0 ) THEN
2392  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
2393  ELSE
2394  temp3 = zero
2395  END IF
2396  result( ntest ) = ( temp1+temp2 ) /
2397  $ max( unfl, temp3*ulp )
2398 *
2399  1460 CONTINUE
2400 *
2401 * 7) Call SSYEVD
2402 *
2403  CALL slacpy( ' ', n, n, a, lda, v, ldu )
2404 *
2405  ntest = ntest + 1
2406  srnamt = 'SSYEVD'
2407  CALL ssyevd( 'V', uplo, n, a, ldu, d1, work, lwedc,
2408  $ iwork, liwedc, iinfo )
2409  IF( iinfo.NE.0 ) THEN
2410  WRITE( nounit, fmt = 9999 )'SSYEVD(V,' // uplo //
2411  $ ')', iinfo, n, jtype, ioldsd
2412  info = abs( iinfo )
2413  IF( iinfo.LT.0 ) THEN
2414  RETURN
2415  ELSE
2416  result( ntest ) = ulpinv
2417  result( ntest+1 ) = ulpinv
2418  result( ntest+2 ) = ulpinv
2419  GO TO 1480
2420  END IF
2421  END IF
2422 *
2423 * Do tests 61 and 62 (or +54)
2424 *
2425  CALL ssyt21( 1, uplo, n, 0, v, ldu, d1, d2, a, ldu, z,
2426  $ ldu, tau, work, result( ntest ) )
2427 *
2428  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2429 *
2430  ntest = ntest + 2
2431  srnamt = 'SSYEVD'
2432  CALL ssyevd( 'N', uplo, n, a, ldu, d3, work, lwedc,
2433  $ iwork, liwedc, iinfo )
2434  IF( iinfo.NE.0 ) THEN
2435  WRITE( nounit, fmt = 9999 )'SSYEVD(N,' // uplo //
2436  $ ')', iinfo, n, jtype, ioldsd
2437  info = abs( iinfo )
2438  IF( iinfo.LT.0 ) THEN
2439  RETURN
2440  ELSE
2441  result( ntest ) = ulpinv
2442  GO TO 1480
2443  END IF
2444  END IF
2445 *
2446 * Do test 63 (or +54)
2447 *
2448  temp1 = zero
2449  temp2 = zero
2450  DO 1470 j = 1, n
2451  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
2452  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
2453  1470 CONTINUE
2454  result( ntest ) = temp2 / max( unfl,
2455  $ ulp*max( temp1, temp2 ) )
2456 *
2457  1480 CONTINUE
2458 *
2459 * 8) Call SSPEVD.
2460 *
2461  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2462 *
2463 * Load array WORK with the upper or lower triangular
2464 * part of the matrix in packed form.
2465 *
2466  IF( iuplo.EQ.1 ) THEN
2467  indx = 1
2468  DO 1500 j = 1, n
2469  DO 1490 i = 1, j
2470  work( indx ) = a( i, j )
2471  indx = indx + 1
2472  1490 CONTINUE
2473  1500 CONTINUE
2474  ELSE
2475  indx = 1
2476  DO 1520 j = 1, n
2477  DO 1510 i = j, n
2478  work( indx ) = a( i, j )
2479  indx = indx + 1
2480  1510 CONTINUE
2481  1520 CONTINUE
2482  END IF
2483 *
2484  ntest = ntest + 1
2485  srnamt = 'SSPEVD'
2486  CALL sspevd( 'V', uplo, n, work, d1, z, ldu,
2487  $ work( indx ), lwedc-indx+1, iwork, liwedc,
2488  $ iinfo )
2489  IF( iinfo.NE.0 ) THEN
2490  WRITE( nounit, fmt = 9999 )'SSPEVD(V,' // uplo //
2491  $ ')', iinfo, n, jtype, ioldsd
2492  info = abs( iinfo )
2493  IF( iinfo.LT.0 ) THEN
2494  RETURN
2495  ELSE
2496  result( ntest ) = ulpinv
2497  result( ntest+1 ) = ulpinv
2498  result( ntest+2 ) = ulpinv
2499  GO TO 1580
2500  END IF
2501  END IF
2502 *
2503 * Do tests 64 and 65 (or +54)
2504 *
2505  CALL ssyt21( 1, uplo, n, 0, a, lda, d1, d2, z, ldu, v,
2506  $ ldu, tau, work, result( ntest ) )
2507 *
2508  IF( iuplo.EQ.1 ) THEN
2509  indx = 1
2510  DO 1540 j = 1, n
2511  DO 1530 i = 1, j
2512 *
2513  work( indx ) = a( i, j )
2514  indx = indx + 1
2515  1530 CONTINUE
2516  1540 CONTINUE
2517  ELSE
2518  indx = 1
2519  DO 1560 j = 1, n
2520  DO 1550 i = j, n
2521  work( indx ) = a( i, j )
2522  indx = indx + 1
2523  1550 CONTINUE
2524  1560 CONTINUE
2525  END IF
2526 *
2527  ntest = ntest + 2
2528  srnamt = 'SSPEVD'
2529  CALL sspevd( 'N', uplo, n, work, d3, z, ldu,
2530  $ work( indx ), lwedc-indx+1, iwork, liwedc,
2531  $ iinfo )
2532  IF( iinfo.NE.0 ) THEN
2533  WRITE( nounit, fmt = 9999 )'SSPEVD(N,' // uplo //
2534  $ ')', iinfo, n, jtype, ioldsd
2535  info = abs( iinfo )
2536  IF( iinfo.LT.0 ) THEN
2537  RETURN
2538  ELSE
2539  result( ntest ) = ulpinv
2540  GO TO 1580
2541  END IF
2542  END IF
2543 *
2544 * Do test 66 (or +54)
2545 *
2546  temp1 = zero
2547  temp2 = zero
2548  DO 1570 j = 1, n
2549  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
2550  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
2551  1570 CONTINUE
2552  result( ntest ) = temp2 / max( unfl,
2553  $ ulp*max( temp1, temp2 ) )
2554  1580 CONTINUE
2555 *
2556 * 9) Call SSBEVD.
2557 *
2558  IF( jtype.LE.7 ) THEN
2559  kd = 1
2560  ELSE IF( jtype.GE.8 .AND. jtype.LE.15 ) THEN
2561  kd = max( n-1, 0 )
2562  ELSE
2563  kd = ihbw
2564  END IF
2565 *
2566 * Load array V with the upper or lower triangular part
2567 * of the matrix in band form.
2568 *
2569  IF( iuplo.EQ.1 ) THEN
2570  DO 1600 j = 1, n
2571  DO 1590 i = max( 1, j-kd ), j
2572  v( kd+1+i-j, j ) = a( i, j )
2573  1590 CONTINUE
2574  1600 CONTINUE
2575  ELSE
2576  DO 1620 j = 1, n
2577  DO 1610 i = j, min( n, j+kd )
2578  v( 1+i-j, j ) = a( i, j )
2579  1610 CONTINUE
2580  1620 CONTINUE
2581  END IF
2582 *
2583  ntest = ntest + 1
2584  srnamt = 'SSBEVD'
2585  CALL ssbevd( 'V', uplo, n, kd, v, ldu, d1, z, ldu, work,
2586  $ lwedc, iwork, liwedc, iinfo )
2587  IF( iinfo.NE.0 ) THEN
2588  WRITE( nounit, fmt = 9999 )'SSBEVD(V,' // uplo //
2589  $ ')', iinfo, n, jtype, ioldsd
2590  info = abs( iinfo )
2591  IF( iinfo.LT.0 ) THEN
2592  RETURN
2593  ELSE
2594  result( ntest ) = ulpinv
2595  result( ntest+1 ) = ulpinv
2596  result( ntest+2 ) = ulpinv
2597  GO TO 1680
2598  END IF
2599  END IF
2600 *
2601 * Do tests 67 and 68 (or +54)
2602 *
2603  CALL ssyt21( 1, uplo, n, 0, a, lda, d1, d2, z, ldu, v,
2604  $ ldu, tau, work, result( ntest ) )
2605 *
2606  IF( iuplo.EQ.1 ) THEN
2607  DO 1640 j = 1, n
2608  DO 1630 i = max( 1, j-kd ), j
2609  v( kd+1+i-j, j ) = a( i, j )
2610  1630 CONTINUE
2611  1640 CONTINUE
2612  ELSE
2613  DO 1660 j = 1, n
2614  DO 1650 i = j, min( n, j+kd )
2615  v( 1+i-j, j ) = a( i, j )
2616  1650 CONTINUE
2617  1660 CONTINUE
2618  END IF
2619 *
2620  ntest = ntest + 2
2621  srnamt = 'SSBEVD'
2622  CALL ssbevd( 'N', uplo, n, kd, v, ldu, d3, z, ldu, work,
2623  $ lwedc, iwork, liwedc, iinfo )
2624  IF( iinfo.NE.0 ) THEN
2625  WRITE( nounit, fmt = 9999 )'SSBEVD(N,' // uplo //
2626  $ ')', iinfo, n, jtype, ioldsd
2627  info = abs( iinfo )
2628  IF( iinfo.LT.0 ) THEN
2629  RETURN
2630  ELSE
2631  result( ntest ) = ulpinv
2632  GO TO 1680
2633  END IF
2634  END IF
2635 *
2636 * Do test 69 (or +54)
2637 *
2638  temp1 = zero
2639  temp2 = zero
2640  DO 1670 j = 1, n
2641  temp1 = max( temp1, abs( d1( j ) ), abs( d3( j ) ) )
2642  temp2 = max( temp2, abs( d1( j )-d3( j ) ) )
2643  1670 CONTINUE
2644  result( ntest ) = temp2 / max( unfl,
2645  $ ulp*max( temp1, temp2 ) )
2646 *
2647  1680 CONTINUE
2648 *
2649 *
2650  CALL slacpy( ' ', n, n, a, lda, v, ldu )
2651  ntest = ntest + 1
2652  srnamt = 'SSYEVR'
2653  CALL ssyevr( 'V', 'A', uplo, n, a, ldu, vl, vu, il, iu,
2654  $ abstol, m, wa1, z, ldu, iwork, work, lwork,
2655  $ iwork(2*n+1), liwork-2*n, iinfo )
2656  IF( iinfo.NE.0 ) THEN
2657  WRITE( nounit, fmt = 9999 )'SSYEVR(V,A,' // uplo //
2658  $ ')', iinfo, n, jtype, ioldsd
2659  info = abs( iinfo )
2660  IF( iinfo.LT.0 ) THEN
2661  RETURN
2662  ELSE
2663  result( ntest ) = ulpinv
2664  result( ntest+1 ) = ulpinv
2665  result( ntest+2 ) = ulpinv
2666  GO TO 1700
2667  END IF
2668  END IF
2669 *
2670 * Do tests 70 and 71 (or ... )
2671 *
2672  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2673 *
2674  CALL ssyt21( 1, uplo, n, 0, a, ldu, wa1, d2, z, ldu, v,
2675  $ ldu, tau, work, result( ntest ) )
2676 *
2677  ntest = ntest + 2
2678  srnamt = 'SSYEVR'
2679  CALL ssyevr( 'N', 'A', uplo, n, a, ldu, vl, vu, il, iu,
2680  $ abstol, m2, wa2, z, ldu, iwork, work, lwork,
2681  $ iwork(2*n+1), liwork-2*n, iinfo )
2682  IF( iinfo.NE.0 ) THEN
2683  WRITE( nounit, fmt = 9999 )'SSYEVR(N,A,' // uplo //
2684  $ ')', iinfo, n, jtype, ioldsd
2685  info = abs( iinfo )
2686  IF( iinfo.LT.0 ) THEN
2687  RETURN
2688  ELSE
2689  result( ntest ) = ulpinv
2690  GO TO 1700
2691  END IF
2692  END IF
2693 *
2694 * Do test 72 (or ... )
2695 *
2696  temp1 = zero
2697  temp2 = zero
2698  DO 1690 j = 1, n
2699  temp1 = max( temp1, abs( wa1( j ) ), abs( wa2( j ) ) )
2700  temp2 = max( temp2, abs( wa1( j )-wa2( j ) ) )
2701  1690 CONTINUE
2702  result( ntest ) = temp2 / max( unfl,
2703  $ ulp*max( temp1, temp2 ) )
2704 *
2705  1700 CONTINUE
2706 *
2707  ntest = ntest + 1
2708  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2709  srnamt = 'SSYEVR'
2710  CALL ssyevr( 'V', 'I', uplo, n, a, ldu, vl, vu, il, iu,
2711  $ abstol, m2, wa2, z, ldu, iwork, work, lwork,
2712  $ iwork(2*n+1), liwork-2*n, iinfo )
2713  IF( iinfo.NE.0 ) THEN
2714  WRITE( nounit, fmt = 9999 )'SSYEVR(V,I,' // uplo //
2715  $ ')', iinfo, n, jtype, ioldsd
2716  info = abs( iinfo )
2717  IF( iinfo.LT.0 ) THEN
2718  RETURN
2719  ELSE
2720  result( ntest ) = ulpinv
2721  result( ntest+1 ) = ulpinv
2722  result( ntest+2 ) = ulpinv
2723  GO TO 1710
2724  END IF
2725  END IF
2726 *
2727 * Do tests 73 and 74 (or +54)
2728 *
2729  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2730 *
2731  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
2732  $ v, ldu, tau, work, result( ntest ) )
2733 *
2734  ntest = ntest + 2
2735  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2736  srnamt = 'SSYEVR'
2737  CALL ssyevr( 'N', 'I', uplo, n, a, ldu, vl, vu, il, iu,
2738  $ abstol, m3, wa3, z, ldu, iwork, work, lwork,
2739  $ iwork(2*n+1), liwork-2*n, iinfo )
2740  IF( iinfo.NE.0 ) THEN
2741  WRITE( nounit, fmt = 9999 )'SSYEVR(N,I,' // uplo //
2742  $ ')', iinfo, n, jtype, ioldsd
2743  info = abs( iinfo )
2744  IF( iinfo.LT.0 ) THEN
2745  RETURN
2746  ELSE
2747  result( ntest ) = ulpinv
2748  GO TO 1710
2749  END IF
2750  END IF
2751 *
2752 * Do test 75 (or +54)
2753 *
2754  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
2755  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
2756  result( ntest ) = ( temp1+temp2 ) /
2757  $ max( unfl, ulp*temp3 )
2758  1710 CONTINUE
2759 *
2760  ntest = ntest + 1
2761  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2762  srnamt = 'SSYEVR'
2763  CALL ssyevr( 'V', 'V', uplo, n, a, ldu, vl, vu, il, iu,
2764  $ abstol, m2, wa2, z, ldu, iwork, work, lwork,
2765  $ iwork(2*n+1), liwork-2*n, iinfo )
2766  IF( iinfo.NE.0 ) THEN
2767  WRITE( nounit, fmt = 9999 )'SSYEVR(V,V,' // uplo //
2768  $ ')', iinfo, n, jtype, ioldsd
2769  info = abs( iinfo )
2770  IF( iinfo.LT.0 ) THEN
2771  RETURN
2772  ELSE
2773  result( ntest ) = ulpinv
2774  result( ntest+1 ) = ulpinv
2775  result( ntest+2 ) = ulpinv
2776  GO TO 700
2777  END IF
2778  END IF
2779 *
2780 * Do tests 76 and 77 (or +54)
2781 *
2782  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2783 *
2784  CALL ssyt22( 1, uplo, n, m2, 0, a, ldu, wa2, d2, z, ldu,
2785  $ v, ldu, tau, work, result( ntest ) )
2786 *
2787  ntest = ntest + 2
2788  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2789  srnamt = 'SSYEVR'
2790  CALL ssyevr( 'N', 'V', uplo, n, a, ldu, vl, vu, il, iu,
2791  $ abstol, m3, wa3, z, ldu, iwork, work, lwork,
2792  $ iwork(2*n+1), liwork-2*n, iinfo )
2793  IF( iinfo.NE.0 ) THEN
2794  WRITE( nounit, fmt = 9999 )'SSYEVR(N,V,' // uplo //
2795  $ ')', iinfo, n, jtype, ioldsd
2796  info = abs( iinfo )
2797  IF( iinfo.LT.0 ) THEN
2798  RETURN
2799  ELSE
2800  result( ntest ) = ulpinv
2801  GO TO 700
2802  END IF
2803  END IF
2804 *
2805  IF( m3.EQ.0 .AND. n.GT.0 ) THEN
2806  result( ntest ) = ulpinv
2807  GO TO 700
2808  END IF
2809 *
2810 * Do test 78 (or +54)
2811 *
2812  temp1 = ssxt1( 1, wa2, m2, wa3, m3, abstol, ulp, unfl )
2813  temp2 = ssxt1( 1, wa3, m3, wa2, m2, abstol, ulp, unfl )
2814  IF( n.GT.0 ) THEN
2815  temp3 = max( abs( wa1( 1 ) ), abs( wa1( n ) ) )
2816  ELSE
2817  temp3 = zero
2818  END IF
2819  result( ntest ) = ( temp1+temp2 ) /
2820  $ max( unfl, temp3*ulp )
2821 *
2822  CALL slacpy( ' ', n, n, v, ldu, a, lda )
2823 *
2824  1720 CONTINUE
2825 *
2826 * End of Loop -- Check for RESULT(j) > THRESH
2827 *
2828  ntestt = ntestt + ntest
2829 *
2830  CALL slafts( 'SST', n, n, jtype, ntest, result, ioldsd,
2831  $ thresh, nounit, nerrs )
2832 *
2833  1730 CONTINUE
2834  1740 CONTINUE
2835 *
2836 * Summary
2837 *
2838  CALL alasvm( 'SST', nounit, nerrs, ntestt, 0 )
2839 *
2840  9999 FORMAT( ' SDRVST: ', a, ' returned INFO=', i6, '.', / 9x, 'N=',
2841  $ i6, ', JTYPE=', i6, ', ISEED=(', 3( i5, ',' ), i5, ')' )
2842 *
2843  RETURN
2844 *
2845 * End of SDRVST
2846 *
subroutine slabad(SMALL, LARGE)
SLABAD
Definition: slabad.f:74
subroutine slaset(UPLO, M, N, ALPHA, BETA, A, LDA)
SLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: slaset.f:110
subroutine slacpy(UPLO, M, N, A, LDA, B, LDB)
SLACPY copies all or part of one two-dimensional array to another.
Definition: slacpy.f:103
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:73
real function slarnd(IDIST, ISEED)
SLARND
Definition: slarnd.f:73
subroutine slatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
SLATMS
Definition: slatms.f:321
subroutine slatmr(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, RSIGN, GRADE, DL, MODEL, CONDL, DR, MODER, CONDR, PIVTNG, IPIVOT, KL, KU, SPARSE, ANORM, PACK, A, LDA, IWORK, INFO)
SLATMR
Definition: slatmr.f:471
subroutine ssbev(JOBZ, UPLO, N, KD, AB, LDAB, W, Z, LDZ, WORK, INFO)
SSBEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices
Definition: ssbev.f:146
subroutine sstevx(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSTEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: sstevx.f:227
subroutine ssbevd(JOBZ, UPLO, N, KD, AB, LDAB, W, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
SSBEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: ssbevd.f:193
subroutine ssbevx(JOBZ, RANGE, UPLO, N, KD, AB, LDAB, Q, LDQ, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSBEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: ssbevx.f:265
subroutine sstev(JOBZ, N, D, E, Z, LDZ, WORK, INFO)
SSTEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices
Definition: sstev.f:116
subroutine sspevx(JOBZ, RANGE, UPLO, N, AP, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSPEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: sspevx.f:234
subroutine sspevd(JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
SSPEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: sspevd.f:178
subroutine sstevd(JOBZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
SSTEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: sstevd.f:163
subroutine sspev(JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, INFO)
SSPEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices
Definition: sspev.f:130
subroutine sstevr(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, IWORK, LIWORK, INFO)
SSTEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: sstevr.f:306
subroutine ssyevr(JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, IWORK, LIWORK, INFO)
SSYEVR computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices
Definition: ssyevr.f:336
subroutine ssyev(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, INFO)
SSYEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices
Definition: ssyev.f:132
subroutine ssyevd(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, IWORK, LIWORK, INFO)
SSYEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices
Definition: ssyevd.f:183
subroutine ssyevx(JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, IWORK, IFAIL, INFO)
SSYEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices
Definition: ssyevx.f:253
subroutine ssyt22(ITYPE, UPLO, N, M, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK, RESULT)
SSYT22
Definition: ssyt22.f:157
subroutine sstt21(N, KBAND, AD, AE, SD, SE, U, LDU, WORK, RESULT)
SSTT21
Definition: sstt21.f:127
real function ssxt1(IJOB, D1, N1, D2, N2, ABSTOL, ULP, UNFL)
SSXT1
Definition: ssxt1.f:106
subroutine sstt22(N, M, KBAND, AD, AE, SD, SE, U, LDU, WORK, LDWORK, RESULT)
SSTT22
Definition: sstt22.f:139
subroutine slafts(TYPE, M, N, IMAT, NTESTS, RESULT, ISEED, THRESH, IOUNIT, IE)
SLAFTS
Definition: slafts.f:99
subroutine ssyt21(ITYPE, UPLO, N, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK, RESULT)
SSYT21
Definition: ssyt21.f:207
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
Here is the call graph for this function:
Here is the caller graph for this function: