.TH "TESTING/EIG/ddrves.f" 3 "Version 3.12.0" "LAPACK" \" -*- nroff -*-
.ad l
.nh
.SH NAME
TESTING/EIG/ddrves.f
.SH SYNOPSIS
.br
.PP
.SS "Functions/Subroutines"

.in +1c
.ti -1c
.RI "subroutine \fBddrves\fP (nsizes, nn, ntypes, dotype, iseed, thresh, nounit, a, lda, h, ht, wr, wi, wrt, wit, vs, ldvs, result, work, nwork, iwork, bwork, info)"
.br
.RI "\fBDDRVES\fP "
.in -1c
.SH "Function/Subroutine Documentation"
.PP 
.SS "subroutine ddrves (integer nsizes, integer, dimension( * ) nn, integer ntypes, logical, dimension( * ) dotype, integer, dimension( 4 ) iseed, double precision thresh, integer nounit, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( lda, * ) h, double precision, dimension( lda, * ) ht, double precision, dimension( * ) wr, double precision, dimension( * ) wi, double precision, dimension( * ) wrt, double precision, dimension( * ) wit, double precision, dimension( ldvs, * ) vs, integer ldvs, double precision, dimension( 13 ) result, double precision, dimension( * ) work, integer nwork, integer, dimension( * ) iwork, logical, dimension( * ) bwork, integer info)"

.PP
\fBDDRVES\fP 
.PP
\fBPurpose:\fP
.RS 4

.PP
.nf
!>
!>    DDRVES checks the nonsymmetric eigenvalue (Schur form) problem
!>    driver DGEES\&.
!>
!>    When DDRVES is called, a number of matrix  () and a
!>    number of matrix  are specified\&.  For each size ()
!>    and each type of matrix, one matrix will be generated and used
!>    to test the nonsymmetric eigenroutines\&.  For each matrix, 13
!>    tests will be performed:
!>
!>    (1)     0 if T is in Schur form, 1/ulp otherwise
!>           (no sorting of eigenvalues)
!>
!>    (2)     | A - VS T VS' | / ( n |A| ulp )
!>
!>      Here VS is the matrix of Schur eigenvectors, and T is in Schur
!>      form  (no sorting of eigenvalues)\&.
!>
!>    (3)     | I - VS VS' | / ( n ulp ) (no sorting of eigenvalues)\&.
!>
!>    (4)     0     if WR+sqrt(-1)*WI are eigenvalues of T
!>            1/ulp otherwise
!>            (no sorting of eigenvalues)
!>
!>    (5)     0     if T(with VS) = T(without VS),
!>            1/ulp otherwise
!>            (no sorting of eigenvalues)
!>
!>    (6)     0     if eigenvalues(with VS) = eigenvalues(without VS),
!>            1/ulp otherwise
!>            (no sorting of eigenvalues)
!>
!>    (7)     0 if T is in Schur form, 1/ulp otherwise
!>            (with sorting of eigenvalues)
!>
!>    (8)     | A - VS T VS' | / ( n |A| ulp )
!>
!>      Here VS is the matrix of Schur eigenvectors, and T is in Schur
!>      form  (with sorting of eigenvalues)\&.
!>
!>    (9)     | I - VS VS' | / ( n ulp ) (with sorting of eigenvalues)\&.
!>
!>    (10)    0     if WR+sqrt(-1)*WI are eigenvalues of T
!>            1/ulp otherwise
!>            (with sorting of eigenvalues)
!>
!>    (11)    0     if T(with VS) = T(without VS),
!>            1/ulp otherwise
!>            (with sorting of eigenvalues)
!>
!>    (12)    0     if eigenvalues(with VS) = eigenvalues(without VS),
!>            1/ulp otherwise
!>            (with sorting of eigenvalues)
!>
!>    (13)    if sorting worked and SDIM is the number of
!>            eigenvalues which were SELECTed
!>
!>    The  are specified by an array NN(1:NSIZES); the value of
!>    each element NN(j) specifies one size\&.
!>    The  are specified by a logical array DOTYPE( 1:NTYPES );
!>    if DOTYPE(j) is \&.TRUE\&., then matrix type  will be generated\&.
!>    Currently, the list of possible types is:
!>
!>    (1)  The zero matrix\&.
!>    (2)  The identity matrix\&.
!>    (3)  A (transposed) Jordan block, with 1's on the diagonal\&.
!>
!>    (4)  A diagonal matrix with evenly spaced entries
!>         1, \&.\&.\&., ULP  and random signs\&.
!>         (ULP = (first number larger than 1) - 1 )
!>    (5)  A diagonal matrix with geometrically spaced entries
!>         1, \&.\&.\&., ULP  and random signs\&.
!>    (6)  A diagonal matrix with  entries 1, ULP, \&.\&.\&., ULP
!>         and random signs\&.
!>
!>    (7)  Same as (4), but multiplied by a constant near
!>         the overflow threshold
!>    (8)  Same as (4), but multiplied by a constant near
!>         the underflow threshold
!>
!>    (9)  A matrix of the form  U' T U, where U is orthogonal and
!>         T has evenly spaced entries 1, \&.\&.\&., ULP with random signs
!>         on the diagonal and random O(1) entries in the upper
!>         triangle\&.
!>
!>    (10) A matrix of the form  U' T U, where U is orthogonal and
!>         T has geometrically spaced entries 1, \&.\&.\&., ULP with random
!>         signs on the diagonal and random O(1) entries in the upper
!>         triangle\&.
!>
!>    (11) A matrix of the form  U' T U, where U is orthogonal and
!>         T has  entries 1, ULP,\&.\&.\&., ULP with random
!>         signs on the diagonal and random O(1) entries in the upper
!>         triangle\&.
!>
!>    (12) A matrix of the form  U' T U, where U is orthogonal and
!>         T has real or complex conjugate paired eigenvalues randomly
!>         chosen from ( ULP, 1 ) and random O(1) entries in the upper
!>         triangle\&.
!>
!>    (13) A matrix of the form  X' T X, where X has condition
!>         SQRT( ULP ) and T has evenly spaced entries 1, \&.\&.\&., ULP
!>         with random signs on the diagonal and random O(1) entries
!>         in the upper triangle\&.
!>
!>    (14) A matrix of the form  X' T X, where X has condition
!>         SQRT( ULP ) and T has geometrically spaced entries
!>         1, \&.\&.\&., ULP with random signs on the diagonal and random
!>         O(1) entries in the upper triangle\&.
!>
!>    (15) A matrix of the form  X' T X, where X has condition
!>         SQRT( ULP ) and T has  entries 1, ULP,\&.\&.\&., ULP
!>         with random signs on the diagonal and random O(1) entries
!>         in the upper triangle\&.
!>
!>    (16) A matrix of the form  X' T X, where X has condition
!>         SQRT( ULP ) and T has real or complex conjugate paired
!>         eigenvalues randomly chosen from ( ULP, 1 ) and random
!>         O(1) entries in the upper triangle\&.
!>
!>    (17) Same as (16), but multiplied by a constant
!>         near the overflow threshold
!>    (18) Same as (16), but multiplied by a constant
!>         near the underflow threshold
!>
!>    (19) Nonsymmetric matrix with random entries chosen from (-1,1)\&.
!>         If N is at least 4, all entries in first two rows and last
!>         row, and first column and last two columns are zero\&.
!>    (20) Same as (19), but multiplied by a constant
!>         near the overflow threshold
!>    (21) Same as (19), but multiplied by a constant
!>         near the underflow threshold
!> 
.fi
.PP
 
.RE
.PP
\fBParameters\fP
.RS 4
\fINSIZES\fP 
.PP
.nf
!>          NSIZES is INTEGER
!>          The number of sizes of matrices to use\&.  If it is zero,
!>          DDRVES does nothing\&.  It must be at least zero\&.
!> 
.fi
.PP
.br
\fINN\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
.br
\fINTYPES\fP 
.PP
.nf
!>          NTYPES is INTEGER
!>          The number of elements in DOTYPE\&.   If it is zero, DDRVES
!>          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\&. \&.
!> 
.fi
.PP
.br
\fIDOTYPE\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
.br
\fIISEED\fP 
.PP
.nf
!>          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 DDRVES to continue the same random number
!>          sequence\&.
!> 
.fi
.PP
.br
\fITHRESH\fP 
.PP
.nf
!>          THRESH is DOUBLE PRECISION
!>          A test will count as  if the , 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\&.
!> 
.fi
.PP
.br
\fINOUNIT\fP 
.PP
.nf
!>          NOUNIT is INTEGER
!>          The FORTRAN unit number for printing out error messages
!>          (e\&.g\&., if a routine returns INFO not equal to 0\&.)
!> 
.fi
.PP
.br
\fIA\fP 
.PP
.nf
!>          A is DOUBLE PRECISION 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\&.
!> 
.fi
.PP
.br
\fILDA\fP 
.PP
.nf
!>          LDA is INTEGER
!>          The leading dimension of A, and H\&. LDA must be at
!>          least 1 and at least max(NN)\&.
!> 
.fi
.PP
.br
\fIH\fP 
.PP
.nf
!>          H is DOUBLE PRECISION array, dimension (LDA, max(NN))
!>          Another copy of the test matrix A, modified by DGEES\&.
!> 
.fi
.PP
.br
\fIHT\fP 
.PP
.nf
!>          HT is DOUBLE PRECISION array, dimension (LDA, max(NN))
!>          Yet another copy of the test matrix A, modified by DGEES\&.
!> 
.fi
.PP
.br
\fIWR\fP 
.PP
.nf
!>          WR is DOUBLE PRECISION array, dimension (max(NN))
!> 
.fi
.PP
.br
\fIWI\fP 
.PP
.nf
!>          WI is DOUBLE PRECISION array, dimension (max(NN))
!>
!>          The real and imaginary parts of the eigenvalues of A\&.
!>          On exit, WR + WI*i are the eigenvalues of the matrix in A\&.
!> 
.fi
.PP
.br
\fIWRT\fP 
.PP
.nf
!>          WRT is DOUBLE PRECISION array, dimension (max(NN))
!> 
.fi
.PP
.br
\fIWIT\fP 
.PP
.nf
!>          WIT is DOUBLE PRECISION array, dimension (max(NN))
!>
!>          Like WR, WI, these arrays contain the eigenvalues of A,
!>          but those computed when DGEES only computes a partial
!>          eigendecomposition, i\&.e\&. not Schur vectors
!> 
.fi
.PP
.br
\fIVS\fP 
.PP
.nf
!>          VS is DOUBLE PRECISION array, dimension (LDVS, max(NN))
!>          VS holds the computed Schur vectors\&.
!> 
.fi
.PP
.br
\fILDVS\fP 
.PP
.nf
!>          LDVS is INTEGER
!>          Leading dimension of VS\&. Must be at least max(1,max(NN))\&.
!> 
.fi
.PP
.br
\fIRESULT\fP 
.PP
.nf
!>          RESULT is DOUBLE PRECISION array, dimension (13)
!>          The values computed by the 13 tests described above\&.
!>          The values are currently limited to 1/ulp, to avoid overflow\&.
!> 
.fi
.PP
.br
\fIWORK\fP 
.PP
.nf
!>          WORK is DOUBLE PRECISION array, dimension (NWORK)
!> 
.fi
.PP
.br
\fINWORK\fP 
.PP
.nf
!>          NWORK is INTEGER
!>          The number of entries in WORK\&.  This must be at least
!>          5*NN(j)+2*NN(j)**2 for all j\&.
!> 
.fi
.PP
.br
\fIIWORK\fP 
.PP
.nf
!>          IWORK is INTEGER array, dimension (max(NN))
!> 
.fi
.PP
.br
\fIBWORK\fP 
.PP
.nf
!>          BWORK is LOGICAL array, dimension (max(NN))
!> 
.fi
.PP
.br
\fIINFO\fP 
.PP
.nf
!>          INFO is INTEGER
!>          If 0, then everything ran OK\&.
!>           -1: NSIZES < 0
!>           -2: Some NN(j) < 0
!>           -3: NTYPES < 0
!>           -6: THRESH < 0
!>           -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) )\&.
!>          -17: LDVS < 1 or LDVS < NMAX, where NMAX is max( NN(j) )\&.
!>          -20: NWORK too small\&.
!>          If  DLATMR, SLATMS, SLATME or DGEES 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\&.
!>     NMAX            Largest value in NN\&.
!>     NERRS           The number of tests which have exceeded THRESH
!>     COND, CONDS,
!>     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\&.
!>     RTULP, RTULPI   Square roots of the previous 4 values\&.
!>
!>             The following four arrays decode JTYPE:
!>     KTYPE(j)        The general type (1-10) for type \&.
!>     KMODE(j)        The MODE value to be passed to the matrix
!>                     generator for type \&.
!>     KMAGN(j)        The order of magnitude ( O(1),
!>                     O(overflow^(1/2) ), O(underflow^(1/2) )
!>     KCONDS(j)       Selectw whether CONDS is to be 1 or
!>                     1/sqrt(ulp)\&.  (0 means irrelevant\&.)
!> 
.fi
.PP
 
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee 

.PP
Univ\&. of California Berkeley 

.PP
Univ\&. of Colorado Denver 

.PP
NAG Ltd\&. 
.RE
.PP

.PP
Definition at line \fB385\fP of file \fBddrves\&.f\fP\&.
.SH "Author"
.PP 
Generated automatically by Doxygen for LAPACK from the source code\&.