DDRGVX

   Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
   November 2006

Purpose

DDRGVX checks the nonsymmetric generalized eigenvalue problem
expert driver DGGEVX.

DGGEVX computes the generalized eigenvalues, (optionally) the left
and/or right eigenvectors, (optionally) computes a balancing
transformation to improve the conditioning, and (optionally)
reciprocal condition numbers for the eigenvalues and eigenvectors.

When DDRGVX is called with NSIZE > 0, two types of test matrix pairs
are generated by the subroutine DLATM6 and test the driver DGGEVX.
The test matrices have the known exact condition numbers for
eigenvalues. For the condition numbers of the eigenvectors
corresponding the first and last eigenvalues are also know
``exactly'' (see DLATM6).

For each matrix pair, the following tests will be performed and
compared with the threshhold THRESH.

(1) max over all left eigenvalue/-vector pairs (beta/alpha,l) of

   | l**H * (beta A - alpha B) | / ( ulp max( |beta A|, |alpha B| ) )

    where l**H is the conjugate tranpose of l.

(2) max over all right eigenvalue/-vector pairs (beta/alpha,r) of

      | (beta A - alpha B) r | / ( ulp max( |beta A|, |alpha B| ) )

(3) The condition number S(i) of eigenvalues computed by DGGEVX
    differs less than a factor THRESH from the exact S(i) (see
    DLATM6).

(4) DIF(i) computed by DTGSNA differs less than a factor 10*THRESH
    from the exact value (for the 1st and 5th vectors only).

Test Matrices

Two kinds of test matrix pairs

         (A, B) = inverse(YH) * (Da, Db) * inverse(X)

are used in the tests:

1: Da = 1+a   0    0    0    0    Db = 1   0   0   0   0
         0   2+a   0    0    0         0   1   0   0   0
         0    0   3+a   0    0         0   0   1   0   0
         0    0    0   4+a   0         0   0   0   1   0
         0    0    0    0   5+a ,      0   0   0   0   1 , and

2: Da =  1   -1    0    0    0    Db = 1   0   0   0   0
         1    1    0    0    0         0   1   0   0   0
         0    0    1    0    0         0   0   1   0   0
         0    0    0   1+a  1+b        0   0   0   1   0
         0    0    0  -1-b  1+a ,      0   0   0   0   1 .

In both cases the same inverse(YH) and inverse(X) are used to compute
(A, B), giving the exact eigenvectors to (A,B) as (YH, X):

YH:  =  1    0   -y    y   -y    X =  1   0  -x  -x   x
        0    1   -y    y   -y         0   1   x  -x  -x
        0    0    1    0    0         0   0   1   0   0
        0    0    0    1    0         0   0   0   1   0
        0    0    0    0    1,        0   0   0   0   1 , where

a, b, x and y will have all values independently of each other from
{ sqrt(sqrt(ULP)),  0.1,  1,  10,  1/sqrt(sqrt(ULP)) }.

Arguments

NSIZE
(input) INTEGER
The number of sizes of matrices to use.  NSIZE must be at
least zero. If it is zero, no randomly generated matrices
are tested, but any test matrices read from NIN will be
tested.
THRESH
(input) DOUBLE PRECISION
A test will count as "failed" if the "error", computed as
described above, exceeds THRESH.  Note that the error
is scaled to be O(1), so THRESH should be a reasonably
small multiple of 1, e.g., 10 or 100.  In particular,
it should not depend on the precision (single vs. double)
or the size of the matrix.  It must be at least zero.
NIN
(input) INTEGER
The FORTRAN unit number for reading in the data file of
problems to solve.
NOUT
(input) INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
(workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
Used to hold the matrix whose eigenvalues are to be
computed.  On exit, A contains the last matrix actually used.
LDA
(input) INTEGER
The leading dimension of A, B, AI, BI, Ao, and Bo.
It must be at least 1 and at least NSIZE.
B
(workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
Used to hold the matrix whose eigenvalues are to be
computed.  On exit, B contains the last matrix actually used.
AI
(workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
Copy of A, modified by DGGEVX.
BI
(workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
Copy of B, modified by DGGEVX.
ALPHAR
(workspace) DOUBLE PRECISION array, dimension (NSIZE)
ALPHAI
(workspace) DOUBLE PRECISION array, dimension (NSIZE)
BETA
(workspace) DOUBLE PRECISION array, dimension (NSIZE)
On exit, (ALPHAR + ALPHAI*i)/BETA are the eigenvalues.
VL
(workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
VL holds the left eigenvectors computed by DGGEVX.
VR
(workspace) DOUBLE PRECISION array, dimension (LDA, NSIZE)
VR holds the right eigenvectors computed by DGGEVX.
ILO
(output/workspace) INTEGER
IHI
(output/workspace) INTEGER
LSCALE
(output/workspace) DOUBLE PRECISION array, dimension (N)
RSCALE
(output/workspace) DOUBLE PRECISION array, dimension (N)
S
(output/workspace) DOUBLE PRECISION array, dimension (N)
DTRU
(output/workspace) DOUBLE PRECISION array, dimension (N)
DIF
(output/workspace) DOUBLE PRECISION array, dimension (N)
DIFTRU
(output/workspace) DOUBLE PRECISION array, dimension (N)
WORK
(workspace) DOUBLE PRECISION array, dimension (LWORK)
LWORK
(input) INTEGER
Leading dimension of WORK.  LWORK >= 2*N*N+12*N+16.
IWORK
(workspace) INTEGER array, dimension (LIWORK)
LIWORK
(input) INTEGER
Leading dimension of IWORK.  Must be at least N+6.
RESULT
(output/workspace) DOUBLE PRECISION array, dimension (4)
BWORK
(workspace) LOGICAL array, dimension (N)
INFO
(output) INTEGER
= 0:  successful exit
< 0:  if INFO = -i, the i-th argument had an illegal value.
> 0:  A routine returned an error code.

Call Graph

Caller Graph