!>
!> ZDRGVX checks the nonsymmetric generalized eigenvalue problem
!> expert driver ZGGEVX.
!>
!> ZGGEVX 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 ZDRGVX is called with NSIZE > 0, two types of test matrix pairs
!> are generated by the subroutine DLATM6 and test the driver ZGGEVX.
!> 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 ZLATM6).
!> For each matrix pair, the following tests will be performed and
!> compared with the threshold 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 transpose 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 ZGGEVX
!>     differs less than a factor THRESH from the exact S(i) (see
!>     ZLATM6).
!>
!> (4) DIF(i) computed by ZTGSNA 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)) }.
!> 

NSIZE

!>          NSIZE is 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.  If it is not zero, then N = 5.
!> 

THRESH

!>          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.
!> 

NIN

!>          NIN is INTEGER
!>          The FORTRAN unit number for reading in the data file of
!>          problems to solve.
!> 

NOUT

!>          NOUT is INTEGER
!>          The FORTRAN unit number for printing out error messages
!>          (e.g., if a routine returns IINFO not equal to 0.)
!> 

A

!>          A is COMPLEX*16 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

!>          LDA is INTEGER
!>          The leading dimension of A, B, AI, BI, Ao, and Bo.
!>          It must be at least 1 and at least NSIZE.
!> 

B

!>          B is COMPLEX*16 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

!>          AI is COMPLEX*16 array, dimension (LDA, NSIZE)
!>          Copy of A, modified by ZGGEVX.
!> 

BI

!>          BI is COMPLEX*16 array, dimension (LDA, NSIZE)
!>          Copy of B, modified by ZGGEVX.
!> 

ALPHA

!>          ALPHA is COMPLEX*16 array, dimension (NSIZE)
!> 

BETA

!>          BETA is COMPLEX*16 array, dimension (NSIZE)
!>
!>          On exit, ALPHA/BETA are the eigenvalues.
!> 

VL

!>          VL is COMPLEX*16 array, dimension (LDA, NSIZE)
!>          VL holds the left eigenvectors computed by ZGGEVX.
!> 

VR

!>          VR is COMPLEX*16 array, dimension (LDA, NSIZE)
!>          VR holds the right eigenvectors computed by ZGGEVX.
!> 

ILO

!>          ILO is INTEGER
!> 

IHI

!>          IHI is INTEGER
!> 

LSCALE

!>          LSCALE is DOUBLE PRECISION array, dimension (N)
!> 

RSCALE

!>          RSCALE is DOUBLE PRECISION array, dimension (N)
!> 

S

!>          S is DOUBLE PRECISION array, dimension (N)
!> 

DTRU

!>          DTRU is DOUBLE PRECISION array, dimension (N)
!> 

DIF

!>          DIF is DOUBLE PRECISION array, dimension (N)
!> 

DIFTRU

!>          DIFTRU is DOUBLE PRECISION array, dimension (N)
!> 

WORK

!>          WORK is COMPLEX*16 array, dimension (LWORK)
!> 

LWORK

!>          LWORK is INTEGER
!>          Leading dimension of WORK.  LWORK >= 2*N*N + 2*N
!> 

RWORK

!>          RWORK is DOUBLE PRECISION array, dimension (6*N)
!> 

IWORK

!>          IWORK is INTEGER array, dimension (LIWORK)
!> 

LIWORK

!>          LIWORK is INTEGER
!>          Leading dimension of IWORK.  LIWORK >= N+2.
!> 

RESULT

!>          RESULT is DOUBLE PRECISION array, dimension (4)
!> 

BWORK

!>          BWORK is LOGICAL array, dimension (N)
!> 

INFO

!>          INFO is INTEGER
!>          = 0:  successful exit
!>          < 0:  if INFO = -i, the i-th argument had an illegal value.
!>          > 0:  A routine returned an error code.
!> 

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.