SRC/DEPRECATED/sgegv.f(3)

NAME
SRC/DEPRECATED/sgegv.f

SYNOPSIS

  Functions/Subroutines
subroutine sgegv (jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info)
SGEGV computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real matrix pair (A,B).

Function/Subroutine Documentation

  subroutine sgegv (character jobvl, character jobvr, integer n, real, dimension( lda, * ) a, integer lda, real, dimension( ldb, * ) b, integer ldb, real, dimension( * ) alphar, real, dimension( * ) alphai, real, dimension( * ) beta, real, dimension( ldvl, * ) vl, integer ldvl, real, dimension( ldvr, * ) vr, integer ldvr, real, dimension( * ) work, integer lwork, integer info)

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

Purpose:

    !>
    !> This routine is deprecated and has been replaced by routine SGGEV.
    !>
    !> SGEGV computes the eigenvalues and, optionally, the left and/or right
    !> eigenvectors of a real 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 REAL array, dimension (LDA, N)
    !>          On entry, the matrix A.
    !>          If JOBVL = 'V' or JOBVR = 'V', then on exit A
    !>          contains the real 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
    !>          blocks from the Schur form will be correct.  See SGGHRD and
    !>          SHGEQZ for details.
    !>

    LDA

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

    B

    !>          B is REAL 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 those elements of
    !>          B corresponding to the diagonal blocks from the Schur form of
    !>          A will be correct.  See SGGHRD and SHGEQZ for details.
    !>

    LDB

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

    ALPHAR

    !>          ALPHAR is REAL array, dimension (N)
    !>          The real parts of each scalar alpha defining an eigenvalue of
    !>          GNEP.
    !>

    ALPHAI

    !>          ALPHAI is REAL array, dimension (N)
    !>          The imaginary parts of each scalar alpha defining an
    !>          eigenvalue of GNEP.  If ALPHAI(j) is zero, then the j-th
    !>          eigenvalue is real; if positive, then the j-th and
    !>          (j+1)-st eigenvalues are a complex conjugate pair, with
    !>          ALPHAI(j+1) = -ALPHAI(j).
    !>

    BETA

    !>          BETA is REAL array, dimension (N)
    !>          The scalars beta that define the eigenvalues of GNEP.
    !>
    !>          Together, the quantities alpha = (ALPHAR(j),ALPHAI(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 REAL 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.
    !>          If the j-th eigenvalue is real, then u(j) = VL(:,j).
    !>          If the j-th and (j+1)-st eigenvalues form a complex conjugate
    !>          pair, then
    !>             u(j) = VL(:,j) + i*VL(:,j+1)
    !>          and
    !>            u(j+1) = VL(:,j) - i*VL(:,j+1).
    !>
    !>          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 REAL 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.
    !>          If the j-th eigenvalue is real, then x(j) = VR(:,j).
    !>          If the j-th and (j+1)-st eigenvalues form a complex conjugate
    !>          pair, then
    !>            x(j) = VR(:,j) + i*VR(:,j+1)
    !>          and
    !>            x(j+1) = VR(:,j) - i*VR(:,j+1).
    !>
    !>          Each eigenvector is scaled so that its largest component has
    !>          abs(real part) + abs(imag. part) = 1, except for eigenvalues
    !>          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 REAL 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,8*N).
    !>          For good performance, LWORK must generally be larger.
    !>          To compute the optimal value of LWORK, call ILAENV to get
    !>          blocksizes (for SGEQRF, SORMQR, and SORGQR.)  Then compute:
    !>          NB  -- MAX of the blocksizes for SGEQRF, SORMQR, and SORGQR;
    !>          The optimal LWORK is:
    !>              2*N + MAX( 6*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.
    !>

    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 ALPHAR(j), ALPHAI(j), and BETA(j)
    !>                should be correct for j=INFO+1,...,N.
    !>          > N:  errors that usually indicate LAPACK problems:
    !>                =N+1: error return from SGGBAL
    !>                =N+2: error return from SGEQRF
    !>                =N+3: error return from SORMQR
    !>                =N+4: error return from SORGQR
    !>                =N+5: error return from SGGHRD
    !>                =N+6: error return from SHGEQZ (other than failed
    !>                                                iteration)
    !>                =N+7: error return from STGEVC
    !>                =N+8: error return from SGGBAK (computing VL)
    !>                =N+9: error return from SGGBAK (computing VR)
    !>                =N+10: error return from SLASCL (various calls)
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  Balancing
    !>  ---------
    !>
    !>  This driver calls SGGBAL 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, SGGBAK 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 real Schur
    !>  form[*] of the  versions of A and B.  If no eigenvectors
    !>  are computed, then only the diagonal blocks will be correct.
    !>
    !>  [*] See SHGEQZ, SGEGS, or read the book ,
    !>      by Golub & van Loan, pub. by Johns Hopkins U. Press.
    !>

Definition at line 304 of file sgegv.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.