TESTING/EIG/dget22.f(3)

NAME
TESTING/EIG/dget22.f

SYNOPSIS

  Functions/Subroutines
subroutine dget22 (transa, transe, transw, n, a, lda, e, lde, wr, wi, work, result)
DGET22

Function/Subroutine Documentation

  subroutine dget22 (character transa, character transe, character transw, integer n, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( lde, * ) e, integer lde, double precision, dimension( * ) wr, double precision, dimension( * ) wi, double precision, dimension( * ) work, double precision, dimension( 2 ) result)

DGET22

Purpose:

    !>
    !> DGET22 does an eigenvector check.
    !>
    !> The basic test is:
    !>
    !>    RESULT(1) = | A E  -  E W | / ( |A| |E| ulp )
    !>
    !> using the 1-norm.  It also tests the normalization of E:
    !>
    !>    RESULT(2) = max | m-norm(E(j)) - 1 | / ( n ulp )
    !>                 j
    !>
    !> where E(j) is the j-th eigenvector, and m-norm is the max-norm of a
    !> vector.  If an eigenvector is complex, as determined from WI(j)
    !> nonzero, then the max-norm of the vector ( er + i*ei ) is the maximum
    !> of
    !>    |er(1)| + |ei(1)|, ... , |er(n)| + |ei(n)|
    !>
    !> W is a block diagonal matrix, with a 1 by 1 block for each real
    !> eigenvalue and a 2 by 2 block for each complex conjugate pair.
    !> If eigenvalues j and j+1 are a complex conjugate pair, so that
    !> WR(j) = WR(j+1) = wr and WI(j) = - WI(j+1) = wi, then the 2 by 2
    !> block corresponding to the pair will be:
    !>
    !>    (  wr  wi  )
    !>    ( -wi  wr  )
    !>
    !> Such a block multiplying an n by 2 matrix ( ur ui ) on the right
    !> will be the same as multiplying  ur + i*ui  by  wr + i*wi.
    !>
    !> To handle various schemes for storage of left eigenvectors, there are
    !> options to use A-transpose instead of A, E-transpose instead of E,
    !> and/or W-transpose instead of W.
    !>

Parameters
    TRANSA

    !>          TRANSA is CHARACTER*1
    !>          Specifies whether or not A is transposed.
    !>          = 'N':  No transpose
    !>          = 'T':  Transpose
    !>          = 'C':  Conjugate transpose (= Transpose)
    !>

    TRANSE

    !>          TRANSE is CHARACTER*1
    !>          Specifies whether or not E is transposed.
    !>          = 'N':  No transpose, eigenvectors are in columns of E
    !>          = 'T':  Transpose, eigenvectors are in rows of E
    !>          = 'C':  Conjugate transpose (= Transpose)
    !>

    TRANSW

    !>          TRANSW is CHARACTER*1
    !>          Specifies whether or not W is transposed.
    !>          = 'N':  No transpose
    !>          = 'T':  Transpose, use -WI(j) instead of WI(j)
    !>          = 'C':  Conjugate transpose, use -WI(j) instead of WI(j)
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    A

    !>          A is DOUBLE PRECISION array, dimension (LDA,N)
    !>          The matrix whose eigenvectors are in E.
    !>

    LDA

    !>          LDA is INTEGER
    !>          The leading dimension of the array A.  LDA >= max(1,N).
    !>

    E

    !>          E is DOUBLE PRECISION array, dimension (LDE,N)
    !>          The matrix of eigenvectors. If TRANSE = 'N', the eigenvectors
    !>          are stored in the columns of E, if TRANSE = 'T' or 'C', the
    !>          eigenvectors are stored in the rows of E.
    !>

    LDE

    !>          LDE is INTEGER
    !>          The leading dimension of the array E.  LDE >= max(1,N).
    !>

    WR

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

    WI

    !>          WI is DOUBLE PRECISION array, dimension (N)
    !>
    !>          The real and imaginary parts of the eigenvalues of A.
    !>          Purely real eigenvalues are indicated by WI(j) = 0.
    !>          Complex conjugate pairs are indicated by WR(j)=WR(j+1) and
    !>          WI(j) = - WI(j+1) non-zero; the real part is assumed to be
    !>          stored in the j-th row/column and the imaginary part in
    !>          the (j+1)-th row/column.
    !>

    WORK

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

    RESULT

    !>          RESULT is DOUBLE PRECISION array, dimension (2)
    !>          RESULT(1) = | A E  -  E W | / ( |A| |E| ulp )
    !>          RESULT(2) = max | m-norm(E(j)) - 1 | / ( n ulp )
    !>                       j
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Definition at line 166 of file dget22.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.