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

.in +1c
.ti -1c
.RI "subroutine \fBddrvsg\fP (nsizes, nn, ntypes, dotype, iseed, thresh, nounit, a, lda, b, ldb, d, z, ldz, ab, bb, ap, bp, work, nwork, iwork, liwork, result, info)"
.br
.RI "\fBDDRVSG\fP "
.in -1c
.SH "Function/Subroutine Documentation"
.PP 
.SS "subroutine ddrvsg (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( ldb, * ) b, integer ldb, double precision, dimension( * ) d, double precision, dimension( ldz, * ) z, integer ldz, double precision, dimension( lda, * ) ab, double precision, dimension( ldb, * ) bb, double precision, dimension( * ) ap, double precision, dimension( * ) bp, double precision, dimension( * ) work, integer nwork, integer, dimension( * ) iwork, integer liwork, double precision, dimension( * ) result, integer info)"

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

.PP
.nf
!>
!>      DDRVSG checks the real symmetric generalized eigenproblem
!>      drivers\&.
!>
!>              DSYGV computes all eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite generalized
!>              eigenproblem\&.
!>
!>              DSYGVD computes all eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite generalized
!>              eigenproblem using a divide and conquer algorithm\&.
!>
!>              DSYGVX computes selected eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite generalized
!>              eigenproblem\&.
!>
!>              DSPGV computes all eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite generalized
!>              eigenproblem in packed storage\&.
!>
!>              DSPGVD computes all eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite generalized
!>              eigenproblem in packed storage using a divide and
!>              conquer algorithm\&.
!>
!>              DSPGVX computes selected eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite generalized
!>              eigenproblem in packed storage\&.
!>
!>              DSBGV computes all eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite banded
!>              generalized eigenproblem\&.
!>
!>              DSBGVD computes all eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite banded
!>              generalized eigenproblem using a divide and conquer
!>              algorithm\&.
!>
!>              DSBGVX computes selected eigenvalues and, optionally,
!>              eigenvectors of a real symmetric-definite banded
!>              generalized eigenproblem\&.
!>
!>      When DDRVSG is called, a number of matrix  () and a
!>      number of matrix  are specified\&.  For each size ()
!>      and each type of matrix, one matrix A of the given type will be
!>      generated; a random well-conditioned matrix B is also generated
!>      and the pair (A,B) is used to test the drivers\&.
!>
!>      For each pair (A,B), the following tests are performed:
!>
!>      (1) DSYGV with ITYPE = 1 and UPLO ='U':
!>
!>              | A Z - B Z D | / ( |A| |Z| n ulp )
!>
!>      (2) as (1) but calling DSPGV
!>      (3) as (1) but calling DSBGV
!>      (4) as (1) but with UPLO = 'L'
!>      (5) as (4) but calling DSPGV
!>      (6) as (4) but calling DSBGV
!>
!>      (7) DSYGV with ITYPE = 2 and UPLO ='U':
!>
!>              | A B Z - Z D | / ( |A| |Z| n ulp )
!>
!>      (8) as (7) but calling DSPGV
!>      (9) as (7) but with UPLO = 'L'
!>      (10) as (9) but calling DSPGV
!>
!>      (11) DSYGV with ITYPE = 3 and UPLO ='U':
!>
!>              | B A Z - Z D | / ( |A| |Z| n ulp )
!>
!>      (12) as (11) but calling DSPGV
!>      (13) as (11) but with UPLO = 'L'
!>      (14) as (13) but calling DSPGV
!>
!>      DSYGVD, DSPGVD and DSBGVD performed the same 14 tests\&.
!>
!>      DSYGVX, DSPGVX and DSBGVX performed the above 14 tests with
!>      the parameter RANGE = 'A', 'N' and 'I', respectively\&.
!>
!>      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\&.
!>      This type is used for the matrix A which has half-bandwidth KA\&.
!>      B is generated as a well-conditioned positive definite matrix
!>      with half-bandwidth KB (<= KA)\&.
!>      Currently, the list of possible types for A is:
!>
!>      (1)  The zero matrix\&.
!>      (2)  The identity matrix\&.
!>
!>      (3)  A diagonal matrix with evenly spaced entries
!>           1, \&.\&.\&., ULP  and random signs\&.
!>           (ULP = (first number larger than 1) - 1 )
!>      (4)  A diagonal matrix with geometrically spaced entries
!>           1, \&.\&.\&., ULP  and random signs\&.
!>      (5)  A diagonal matrix with  entries
!>           1, ULP, \&.\&.\&., ULP and random signs\&.
!>
!>      (6)  Same as (4), but multiplied by SQRT( overflow threshold )
!>      (7)  Same as (4), but multiplied by SQRT( underflow threshold )
!>
!>      (8)  A matrix of the form  U* D U, where U is 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  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) Same as (8), but with KA = 1 and KB = 1
!>      (17) Same as (8), but with KA = 2 and KB = 1
!>      (18) Same as (8), but with KA = 2 and KB = 2
!>      (19) Same as (8), but with KA = 3 and KB = 1
!>      (20) Same as (8), but with KA = 3 and KB = 2
!>      (21) Same as (8), but with KA = 3 and KB = 3
!> 
.fi
.PP
 
.PP
.nf
!>  NSIZES  INTEGER
!>          The number of sizes of matrices to use\&.  If it is zero,
!>          DDRVSG 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, DDRVSG
!>          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 DDRVSG to continue the same random number
!>          sequence\&.
!>          Modified\&.
!>
!>  THRESH  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\&.
!>          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       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\&.
!>          Modified\&.
!>
!>  LDA     INTEGER
!>          The leading dimension of A and AB\&.  It must be at
!>          least 1 and at least max( NN )\&.
!>          Not modified\&.
!>
!>  B       DOUBLE PRECISION array, dimension (LDB , max(NN))
!>          Used to hold the symmetric positive definite matrix for
!>          the generalized problem\&.
!>          On exit, B contains the last matrix actually
!>          used\&.
!>          Modified\&.
!>
!>  LDB     INTEGER
!>          The leading dimension of B and BB\&.  It must be at
!>          least 1 and at least max( NN )\&.
!>          Not modified\&.
!>
!>  D       DOUBLE PRECISION array, dimension (max(NN))
!>          The eigenvalues of A\&. On exit, the eigenvalues in D
!>          correspond with the matrix in A\&.
!>          Modified\&.
!>
!>  Z       DOUBLE PRECISION array, dimension (LDZ, max(NN))
!>          The matrix of eigenvectors\&.
!>          Modified\&.
!>
!>  LDZ     INTEGER
!>          The leading dimension of Z\&.  It must be at least 1 and
!>          at least max( NN )\&.
!>          Not modified\&.
!>
!>  AB      DOUBLE PRECISION array, dimension (LDA, max(NN))
!>          Workspace\&.
!>          Modified\&.
!>
!>  BB      DOUBLE PRECISION array, dimension (LDB, max(NN))
!>          Workspace\&.
!>          Modified\&.
!>
!>  AP      DOUBLE PRECISION array, dimension (max(NN)**2)
!>          Workspace\&.
!>          Modified\&.
!>
!>  BP      DOUBLE PRECISION array, dimension (max(NN)**2)
!>          Workspace\&.
!>          Modified\&.
!>
!>  WORK    DOUBLE PRECISION array, dimension (NWORK)
!>          Workspace\&.
!>          Modified\&.
!>
!>  NWORK   INTEGER
!>          The number of entries in WORK\&.  This must be at least
!>          1+5*N+2*N*lg(N)+3*N**2 where N = max( NN(j) ) and
!>          lg( N ) = smallest integer k such that 2**k >= N\&.
!>          Not modified\&.
!>
!>  IWORK   INTEGER array, dimension (LIWORK)
!>          Workspace\&.
!>          Modified\&.
!>
!>  LIWORK  INTEGER
!>          The number of entries in WORK\&.  This must be at least 6*N\&.
!>          Not modified\&.
!>
!>  RESULT  DOUBLE PRECISION array, dimension (70)
!>          The values computed by the 70 tests described above\&.
!>          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: LDZ < 1 or LDZ < NMAX\&.
!>          -21: NWORK too small\&.
!>          -23: LIWORK too small\&.
!>          If  DLATMR, SLATMS, DSYGV, DSPGV, DSBGV, SSYGVD, SSPGVD,
!>              DSBGVD, DSYGVX, DSPGVX or SSBGVX 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 that have been run
!>                       on this matrix\&.
!>       NTESTT          The total number of tests for this call\&.
!>       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 DLAFTS)\&.
!>       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 \&.
!>       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) )
!> 
.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 \fB352\fP of file \fBddrvsg\&.f\fP\&.
.SH "Author"
.PP 
Generated automatically by Doxygen for LAPACK from the source code\&.