cdrvsg.f

来自「famous linear algebra library (LAPACK) p」· F 代码 · 共 1,291 行 · 第 1/4 页

      SUBROUTINE CDRVSG( NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH,
     $                   NOUNIT, A, LDA, B, LDB, D, Z, LDZ, AB, BB, AP,
     $                   BP, WORK, NWORK, RWORK, LRWORK, IWORK, LIWORK,
     $                   RESULT, INFO )
*
*  -- LAPACK test routine (version 3.1) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     November 2006
*
**********************************************************************
*
*     modified August 1997, a new parameter LRWORK and LIWORK are
*     added in the calling sequence.
*
*     test routine CSGT01 is also modified
*
**********************************************************************
*
*     .. Scalar Arguments ..
      INTEGER            INFO, LDA, LDB, LDZ, LIWORK, LRWORK, NOUNIT,
     $                   NSIZES, NTYPES, NWORK
      REAL               THRESH
*     ..
*     .. Array Arguments ..
      LOGICAL            DOTYPE( * )
      INTEGER            ISEED( 4 ), IWORK( * ), NN( * )
      REAL               D( * ), RESULT( * ), RWORK( * )
      COMPLEX            A( LDA, * ), AB( LDA, * ), AP( * ),
     $                   B( LDB, * ), BB( LDB, * ), BP( * ), WORK( * ),
     $                   Z( LDZ, * )
*     ..
*
*  Purpose
*  =======
*
*       CDRVSG checks the complex Hermitian generalized eigenproblem
*       drivers.
*
*               CHEGV computes all eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite generalized
*               eigenproblem.
*
*               CHEGVD computes all eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite generalized
*               eigenproblem using a divide and conquer algorithm.
*
*               CHEGVX computes selected eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite generalized
*               eigenproblem.
*
*               CHPGV computes all eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite generalized
*               eigenproblem in packed storage.
*
*               CHPGVD computes all eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite generalized
*               eigenproblem in packed storage using a divide and
*               conquer algorithm.
*
*               CHPGVX computes selected eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite generalized
*               eigenproblem in packed storage.
*
*               CHBGV computes all eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite banded
*               generalized eigenproblem.
*
*               CHBGVD computes all eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite banded
*               generalized eigenproblem using a divide and conquer
*               algorithm.
*
*               CHBGVX computes selected eigenvalues and, optionally,
*               eigenvectors of a complex Hermitian-definite banded
*               generalized eigenproblem.
*
*       When CDRVSG 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 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) CHEGV with ITYPE = 1 and UPLO ='U':
*
*               | A Z - B Z D | / ( |A| |Z| n ulp )
*
*       (2) as (1) but calling CHPGV
*       (3) as (1) but calling CHBGV
*       (4) as (1) but with UPLO = 'L'
*       (5) as (4) but calling CHPGV
*       (6) as (4) but calling CHBGV
*
*       (7) CHEGV with ITYPE = 2 and UPLO ='U':
*
*               | A B Z - Z D | / ( |A| |Z| n ulp )
*
*       (8) as (7) but calling CHPGV
*       (9) as (7) but with UPLO = 'L'
*       (10) as (9) but calling CHPGV
*
*       (11) CHEGV with ITYPE = 3 and UPLO ='U':
*
*               | B A Z - Z D | / ( |A| |Z| n ulp )
*
*       (12) as (11) but calling CHPGV
*       (13) as (11) but with UPLO = 'L'
*       (14) as (13) but calling CHPGV
*
*       CHEGVD, CHPGVD and CHBGVD performed the same 14 tests.
*
*       CHEGVX, CHPGVX and CHBGVX performed the above 14 tests with
*       the parameter RANGE = 'A', 'N' and 'I', respectively.
*
*       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.
*       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 "clustered" entries 1, ULP, ..., ULP
*            and random signs.
*
*       (6)  Same as (4), but multiplied by SQRT( overflow threshold )
*       (7)  Same as (4), but multiplied by SQRT( underflow threshold )
*
*       (8)  A matrix of the form  U* D U, where U is unitary and
*            D has evenly spaced entries 1, ..., ULP with random signs
*            on the diagonal.
*
*       (9)  A matrix of the form  U* D U, where U is unitary and
*            D has geometrically spaced entries 1, ..., ULP with random
*            signs on the diagonal.
*
*       (10) A matrix of the form  U* D U, where U is unitary and
*            D has "clustered" entries 1, ULP,..., ULP with random
*            signs on the diagonal.
*
*       (11) Same as (8), but multiplied by SQRT( overflow threshold )
*       (12) Same as (8), but multiplied by SQRT( underflow threshold )
*
*       (13) Hermitian matrix with random entries chosen from (-1,1).
*       (14) Same as (13), but multiplied by SQRT( overflow threshold )
*       (15) Same as (13), but multiplied by SQRT( underflow threshold )
*
*       (16) Same as (8), but 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
*
*  Arguments
*  =========
*
*  NSIZES  INTEGER
*          The number of sizes of matrices to use.  If it is zero,
*          CDRVSG 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, CDRVSG
*          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 CDRVSG 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       COMPLEX 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.
*
*  B       COMPLEX array, dimension (LDB , max(NN))
*          Used to hold the Hermitian positive definite matrix for
*          the generailzed problem.
*          On exit, B contains the last matrix actually
*          used.
*          Modified.
*
*  LDB     INTEGER
*          The leading dimension of B.  It must be at
*          least 1 and at least max( NN ).
*          Not modified.
*
*  D       REAL array, dimension (max(NN))
*          The eigenvalues of A. On exit, the eigenvalues in D
*          correspond with the matrix in A.
*          Modified.
*
*  Z       COMPLEX array, dimension (LDZ, max(NN))
*          The matrix of eigenvectors.
*          Modified.
*
*  LDZ     INTEGER
*          The leading dimension of ZZ.  It must be at least 1 and
*          at least max( NN ).
*          Not modified.
*
*  AB      COMPLEX array, dimension (LDA, max(NN))
*          Workspace.
*          Modified.
*
*  BB      COMPLEX array, dimension (LDB, max(NN))
*          Workspace.
*          Modified.
*
*  AP      COMPLEX array, dimension (max(NN)**2)
*          Workspace.
*          Modified.
*
*  BP      COMPLEX array, dimension (max(NN)**2)
*          Workspace.
*          Modified.
*
*  WORK    COMPLEX array, dimension (NWORK)
*          Workspace.
*          Modified.
*
*  NWORK   INTEGER
*          The number of entries in WORK.  This must be at least
*          2*N + N**2  where  N = max( NN(j), 2 ).
*          Not modified.
*
*  RWORK   REAL array, dimension (LRWORK)
*          Workspace.
*          Modified.
*
*  LRWORK  INTEGER
*          The number of entries in RWORK.  This must be at least
*          max( 7*N, 1 + 4*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 IWORK.  This must be at least
*          2 + 5*max( NN(j) ).
*          Not modified.
*
*  RESULT  REAL 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: LRWORK too small.
*          -25: LIWORK too small.
*          If  CLATMR, CLATMS, CHEGV, CHPGV, CHBGV, CHEGVD, CHPGVD,
*              CHPGVD, CHEGVX, CHPGVX, CHBGVX returns an error code,
*              the absolute value of it is returned.