TESTING/EIG/dget52.f(3)

NAME
TESTING/EIG/dget52.f

SYNOPSIS

  Functions/Subroutines
subroutine dget52 (left, n, a, lda, b, ldb, e, lde, alphar, alphai, beta, work, result)
DGET52

Function/Subroutine Documentation

  subroutine dget52 (logical left, integer n, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( ldb, * ) b, integer ldb, double precision, dimension( lde, * ) e, integer lde, double precision, dimension( * ) alphar, double precision, dimension( * ) alphai, double precision, dimension( * ) beta, double precision, dimension( * ) work, double precision, dimension( 2 ) result)

DGET52

Purpose:

    !>
    !> DGET52  does an eigenvector check for the generalized eigenvalue
    !> problem.
    !>
    !> The basic test for right eigenvectors is:
    !>
    !>                           | b(j) A E(j) -  a(j) B E(j) |
    !>         RESULT(1) = max   -------------------------------
    !>                      j    n ulp max( |b(j) A|, |a(j) B| )
    !>
    !> using the 1-norm.  Here, a(j)/b(j) = w is the j-th generalized
    !> eigenvalue of A - w B, or, equivalently, b(j)/a(j) = m is the j-th
    !> generalized eigenvalue of m A - B.
    !>
    !> For real eigenvalues, the test is straightforward.  For complex
    !> eigenvalues, E(j) and a(j) are complex, represented by
    !> Er(j) + i*Ei(j) and ar(j) + i*ai(j), resp., so the test for that
    !> eigenvector becomes
    !>
    !>                 max( |Wr|, |Wi| )
    !>     --------------------------------------------
    !>     n ulp max( |b(j) A|, (|ar(j)|+|ai(j)|) |B| )
    !>
    !> where
    !>
    !>     Wr = b(j) A Er(j) - ar(j) B Er(j) + ai(j) B Ei(j)
    !>
    !>     Wi = b(j) A Ei(j) - ai(j) B Er(j) - ar(j) B Ei(j)
    !>
    !>                         T   T  _
    !> For left eigenvectors, A , B , a, and b  are used.
    !>
    !> DGET52 also tests the normalization of E.  Each eigenvector is
    !> supposed to be normalized so that the maximum
    !> of its elements is 1, where in this case,
    !> of a complex value x is  |Re(x)| + |Im(x)| ; let us call this
    !> maximum  norm of a vector v  M(v).
    !> if a(j)=b(j)=0, then the eigenvector is set to be the jth coordinate
    !> vector.  The normalization test is:
    !>
    !>         RESULT(2) =      max       | M(v(j)) - 1 | / ( n ulp )
    !>                    eigenvectors v(j)
    !>

Parameters
    LEFT

    !>          LEFT is LOGICAL
    !>          =.TRUE.:  The eigenvectors in the columns of E are assumed
    !>                    to be *left* eigenvectors.
    !>          =.FALSE.: The eigenvectors in the columns of E are assumed
    !>                    to be *right* eigenvectors.
    !>

    N

    !>          N is INTEGER
    !>          The size of the matrices.  If it is zero, DGET52 does
    !>          nothing.  It must be at least zero.
    !>

    A

    !>          A is DOUBLE PRECISION array, dimension (LDA, N)
    !>          The matrix A.
    !>

    LDA

    !>          LDA is INTEGER
    !>          The leading dimension of A.  It must be at least 1
    !>          and at least N.
    !>

    B

    !>          B is DOUBLE PRECISION array, dimension (LDB, N)
    !>          The matrix B.
    !>

    LDB

    !>          LDB is INTEGER
    !>          The leading dimension of B.  It must be at least 1
    !>          and at least N.
    !>

    E

    !>          E is DOUBLE PRECISION array, dimension (LDE, N)
    !>          The matrix of eigenvectors.  It must be O( 1 ).  Complex
    !>          eigenvalues and eigenvectors always come in pairs, the
    !>          eigenvalue and its conjugate being stored in adjacent
    !>          elements of ALPHAR, ALPHAI, and BETA.  Thus, if a(j)/b(j)
    !>          and a(j+1)/b(j+1) are a complex conjugate pair of
    !>          generalized eigenvalues, then E(,j) contains the real part
    !>          of the eigenvector and E(,j+1) contains the imaginary part.
    !>          Note that whether E(,j) is a real eigenvector or part of a
    !>          complex one is specified by whether ALPHAI(j) is zero or not.
    !>

    LDE

    !>          LDE is INTEGER
    !>          The leading dimension of E.  It must be at least 1 and at
    !>          least N.
    !>

    ALPHAR

    !>          ALPHAR is DOUBLE PRECISION array, dimension (N)
    !>          The real parts of the values a(j) as described above, which,
    !>          along with b(j), define the generalized eigenvalues.
    !>          Complex eigenvalues always come in complex conjugate pairs
    !>          a(j)/b(j) and a(j+1)/b(j+1), which are stored in adjacent
    !>          elements in ALPHAR, ALPHAI, and BETA.  Thus, if the j-th
    !>          and (j+1)-st eigenvalues form a pair, ALPHAR(j+1)/BETA(j+1)
    !>          is assumed to be equal to ALPHAR(j)/BETA(j).
    !>

    ALPHAI

    !>          ALPHAI is DOUBLE PRECISION array, dimension (N)
    !>          The imaginary parts of the values a(j) as described above,
    !>          which, along with b(j), define the generalized eigenvalues.
    !>          If ALPHAI(j)=0, then the eigenvalue is real, otherwise it
    !>          is part of a complex conjugate pair.  Complex eigenvalues
    !>          always come in complex conjugate pairs a(j)/b(j) and
    !>          a(j+1)/b(j+1), which are stored in adjacent elements in
    !>          ALPHAR, ALPHAI, and BETA.  Thus, if the j-th and (j+1)-st
    !>          eigenvalues form a pair, ALPHAI(j+1)/BETA(j+1) is assumed to
    !>          be equal to  -ALPHAI(j)/BETA(j).  Also, nonzero values in
    !>          ALPHAI are assumed to always come in adjacent pairs.
    !>

    BETA

    !>          BETA is DOUBLE PRECISION array, dimension (N)
    !>          The values b(j) as described above, which, along with a(j),
    !>          define the generalized eigenvalues.
    !>

    WORK

    !>          WORK is DOUBLE PRECISION array, dimension (N**2+N)
    !>

    RESULT

    !>          RESULT is DOUBLE PRECISION array, dimension (2)
    !>          The values computed by the test described above.  If A E or
    !>          B E is likely to overflow, then RESULT(1:2) is set to
    !>          10 / ulp.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Definition at line 197 of file dget52.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.