SRC/DEPRECATED/cgegv.f(3)

NAME
SRC/DEPRECATED/cgegv.f

SYNOPSIS

  Functions/Subroutines
subroutine cgegv (jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
CGEGV computes the eigenvalues and, optionally, the left and/or right eigenvectors of a complex matrix pair (A,B).

Function/Subroutine Documentation

  subroutine cgegv (character jobvl, character jobvr, integer n, complex, dimension( lda, * ) a, integer lda, complex, dimension( ldb, * ) b, integer ldb, complex, dimension( * ) alpha, complex, dimension( * ) beta, complex, dimension( ldvl, * ) vl, integer ldvl, complex, dimension( ldvr, * ) vr, integer ldvr, complex, dimension( * ) work, integer lwork, real, dimension( * ) rwork, integer info)

CGEGV computes the eigenvalues and, optionally, the left and/or right eigenvectors of a complex matrix pair (A,B).

Purpose:

    !>
    !> This routine is deprecated and has been replaced by routine CGGEV.
    !>
    !> CGEGV computes the eigenvalues and, optionally, the left and/or right
    !> eigenvectors of a complex matrix pair (A,B).
    !> Given two square matrices A and B,
    !> the generalized nonsymmetric eigenvalue problem (GNEP) is to find the
    !> eigenvalues lambda and corresponding (non-zero) eigenvectors x such
    !> that
    !>    A*x = lambda*B*x.
    !>
    !> An alternate form is to find the eigenvalues mu and corresponding
    !> eigenvectors y such that
    !>    mu*A*y = B*y.
    !>
    !> These two forms are equivalent with mu = 1/lambda and x = y if
    !> neither lambda nor mu is zero.  In order to deal with the case that
    !> lambda or mu is zero or small, two values alpha and beta are returned
    !> for each eigenvalue, such that lambda = alpha/beta and
    !> mu = beta/alpha.
    !>
    !> The vectors x and y in the above equations are right eigenvectors of
    !> the matrix pair (A,B).  Vectors u and v satisfying
    !>    u**H*A = lambda*u**H*B  or  mu*v**H*A = v**H*B
    !> are left eigenvectors of (A,B).
    !>
    !> Note: this routine performs  on A and B
    !>

Parameters
    JOBVL

    !>          JOBVL is CHARACTER*1
    !>          = 'N':  do not compute the left generalized eigenvectors;
    !>          = 'V':  compute the left generalized eigenvectors (returned
    !>                  in VL).
    !>

    JOBVR

    !>          JOBVR is CHARACTER*1
    !>          = 'N':  do not compute the right generalized eigenvectors;
    !>          = 'V':  compute the right generalized eigenvectors (returned
    !>                  in VR).
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrices A, B, VL, and VR.  N >= 0.
    !>

    A

    !>          A is COMPLEX array, dimension (LDA, N)
    !>          On entry, the matrix A.
    !>          If JOBVL = 'V' or JOBVR = 'V', then on exit A
    !>          contains the Schur form of A from the generalized Schur
    !>          factorization of the pair (A,B) after balancing.  If no
    !>          eigenvectors were computed, then only the diagonal elements
    !>          of the Schur form will be correct.  See CGGHRD and CHGEQZ
    !>          for details.
    !>

    LDA

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

    B

    !>          B is COMPLEX array, dimension (LDB, N)
    !>          On entry, the matrix B.
    !>          If JOBVL = 'V' or JOBVR = 'V', then on exit B contains the
    !>          upper triangular matrix obtained from B in the generalized
    !>          Schur factorization of the pair (A,B) after balancing.
    !>          If no eigenvectors were computed, then only the diagonal
    !>          elements of B will be correct.  See CGGHRD and CHGEQZ for
    !>          details.
    !>

    LDB

    !>          LDB is INTEGER
    !>          The leading dimension of B.  LDB >= max(1,N).
    !>

    ALPHA

    !>          ALPHA is COMPLEX array, dimension (N)
    !>          The complex scalars alpha that define the eigenvalues of
    !>          GNEP.
    !>

    BETA

    !>          BETA is COMPLEX array, dimension (N)
    !>          The complex scalars beta that define the eigenvalues of GNEP.
    !>
    !>          Together, the quantities alpha = ALPHA(j) and beta = BETA(j)
    !>          represent the j-th eigenvalue of the matrix pair (A,B), in
    !>          one of the forms lambda = alpha/beta or mu = beta/alpha.
    !>          Since either lambda or mu may overflow, they should not,
    !>          in general, be computed.
    !>

    VL

    !>          VL is COMPLEX array, dimension (LDVL,N)
    !>          If JOBVL = 'V', the left eigenvectors u(j) are stored
    !>          in the columns of VL, in the same order as their eigenvalues.
    !>          Each eigenvector is scaled so that its largest component has
    !>          abs(real part) + abs(imag. part) = 1, except for eigenvectors
    !>          corresponding to an eigenvalue with alpha = beta = 0, which
    !>          are set to zero.
    !>          Not referenced if JOBVL = 'N'.
    !>

    LDVL

    !>          LDVL is INTEGER
    !>          The leading dimension of the matrix VL. LDVL >= 1, and
    !>          if JOBVL = 'V', LDVL >= N.
    !>

    VR

    !>          VR is COMPLEX array, dimension (LDVR,N)
    !>          If JOBVR = 'V', the right eigenvectors x(j) are stored
    !>          in the columns of VR, in the same order as their eigenvalues.
    !>          Each eigenvector is scaled so that its largest component has
    !>          abs(real part) + abs(imag. part) = 1, except for eigenvectors
    !>          corresponding to an eigenvalue with alpha = beta = 0, which
    !>          are set to zero.
    !>          Not referenced if JOBVR = 'N'.
    !>

    LDVR

    !>          LDVR is INTEGER
    !>          The leading dimension of the matrix VR. LDVR >= 1, and
    !>          if JOBVR = 'V', LDVR >= N.
    !>

    WORK

    !>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
    !>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
    !>

    LWORK

    !>          LWORK is INTEGER
    !>          The dimension of the array WORK.  LWORK >= max(1,2*N).
    !>          For good performance, LWORK must generally be larger.
    !>          To compute the optimal value of LWORK, call ILAENV to get
    !>          blocksizes (for CGEQRF, CUNMQR, and CUNGQR.)  Then compute:
    !>          NB  -- MAX of the blocksizes for CGEQRF, CUNMQR, and CUNGQR;
    !>          The optimal LWORK is  MAX( 2*N, N*(NB+1) ).
    !>
    !>          If LWORK = -1, then a workspace query is assumed; the routine
    !>          only calculates the optimal size of the WORK array, returns
    !>          this value as the first entry of the WORK array, and no error
    !>          message related to LWORK is issued by XERBLA.
    !>

    RWORK

    !>          RWORK is REAL array, dimension (8*N)
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0:  successful exit
    !>          < 0:  if INFO = -i, the i-th argument had an illegal value.
    !>          =1,...,N:
    !>                The QZ iteration failed.  No eigenvectors have been
    !>                calculated, but ALPHA(j) and BETA(j) should be
    !>                correct for j=INFO+1,...,N.
    !>          > N:  errors that usually indicate LAPACK problems:
    !>                =N+1: error return from CGGBAL
    !>                =N+2: error return from CGEQRF
    !>                =N+3: error return from CUNMQR
    !>                =N+4: error return from CUNGQR
    !>                =N+5: error return from CGGHRD
    !>                =N+6: error return from CHGEQZ (other than failed
    !>                                               iteration)
    !>                =N+7: error return from CTGEVC
    !>                =N+8: error return from CGGBAK (computing VL)
    !>                =N+9: error return from CGGBAK (computing VR)
    !>                =N+10: error return from CLASCL (various calls)
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  Balancing
    !>  ---------
    !>
    !>  This driver calls CGGBAL to both permute and scale rows and columns
    !>  of A and B.  The permutations PL and PR are chosen so that PL*A*PR
    !>  and PL*B*R will be upper triangular except for the diagonal blocks
    !>  A(i:j,i:j) and B(i:j,i:j), with i and j as close together as
    !>  possible.  The diagonal scaling matrices DL and DR are chosen so
    !>  that the pair  DL*PL*A*PR*DR, DL*PL*B*PR*DR have elements close to
    !>  one (except for the elements that start out zero.)
    !>
    !>  After the eigenvalues and eigenvectors of the balanced matrices
    !>  have been computed, CGGBAK transforms the eigenvectors back to what
    !>  they would have been (in perfect arithmetic) if they had not been
    !>  balanced.
    !>
    !>  Contents of A and B on Exit
    !>  -------- -- - --- - -- ----
    !>
    !>  If any eigenvectors are computed (either JOBVL='V' or JOBVR='V' or
    !>  both), then on exit the arrays A and B will contain the complex Schur
    !>  form[*] of the  versions of A and B.  If no eigenvectors
    !>  are computed, then only the diagonal blocks will be correct.
    !>
    !>  [*] In other words, upper triangular form.
    !>

Definition at line 280 of file cgegv.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.