Loading...
Searching...
No Matches

## cggevx()

subroutine cggevx | ( | character | balanc,
|  | character | jobvl,
|  | character | jobvr,
|  | character | sense,
|  | 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,
|  | integer | ilo,
|  | integer | ihi,
|  | real, dimension( * ) | lscale,
|  | real, dimension( * ) | rscale,
|  | real | abnrm,
|  | real | bbnrm,
|  | real, dimension( * ) | rconde,
|  | real, dimension( * ) | rcondv,
|  | complex, dimension( * ) | work,
|  | integer | lwork,
|  | real, dimension( * ) | rwork,
|  | integer, dimension( * ) | iwork,
|  | logical, dimension( * ) | bwork,
|  | integer | info )

CGGEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices

Download CGGEVX + dependencies [TGZ] [ZIP] [TXT]

Purpose:

      !>
      !> CGGEVX computes for a pair of N-by-N complex nonsymmetric matrices
      !> (A,B) the generalized eigenvalues, and optionally, the left and/or
      !> right generalized eigenvectors.
      !>
      !> Optionally, it also computes a balancing transformation to improve
      !> the conditioning of the eigenvalues and eigenvectors (ILO, IHI,
      !> LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for
      !> the eigenvalues (RCONDE), and reciprocal condition numbers for the
      !> right eigenvectors (RCONDV).
      !>
      !> A generalized eigenvalue for a pair of matrices (A,B) is a scalar
      !> lambda or a ratio alpha/beta = lambda, such that A - lambda*B is
      !> singular. It is usually represented as the pair (alpha,beta), as
      !> there is a reasonable interpretation for beta=0, and even for both
      !> being zero.
      !>
      !> The right eigenvector v(j) corresponding to the eigenvalue lambda(j)
      !> of (A,B) satisfies
      !>                  A * v(j) = lambda(j) * B * v(j) .
      !> The left eigenvector u(j) corresponding to the eigenvalue lambda(j)
      !> of (A,B) satisfies
      !>                  u(j)**H * A  = lambda(j) * u(j)**H * B.
      !> where u(j)**H is the conjugate-transpose of u(j).
      !>
      !>

Parameters

  [in]

  BALANC

      !>          BALANC is CHARACTER*1
      !>          Specifies the balance option to be performed:
      !>          = 'N':  do not diagonally scale or permute;
      !>          = 'P':  permute only;
      !>          = 'S':  scale only;
      !>          = 'B':  both permute and scale.
      !>          Computed reciprocal condition numbers will be for the
      !>          matrices after permuting and/or balancing. Permuting does
      !>          not change condition numbers (in exact arithmetic), but
      !>          balancing does.
      !>

  [in]

  JOBVL

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

  [in]

  JOBVR

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

  [in]

  SENSE

      !>          SENSE is CHARACTER*1
      !>          Determines which reciprocal condition numbers are computed.
      !>          = 'N': none are computed;
      !>          = 'E': computed for eigenvalues only;
      !>          = 'V': computed for eigenvectors only;
      !>          = 'B': computed for eigenvalues and eigenvectors.
      !>

  [in]

  N

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

  [in,out]

  A

      !>          A is COMPLEX array, dimension (LDA, N)
      !>          On entry, the matrix A in the pair (A,B).
      !>          On exit, A has been overwritten. If JOBVL='V' or JOBVR='V'
      !>          or both, then A contains the first part of the complex Schur
      !>          form of the  versions of the input A and B.
      !>

  [in]

  LDA

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

  [in,out]

  B

      !>          B is COMPLEX array, dimension (LDB, N)
      !>          On entry, the matrix B in the pair (A,B).
      !>          On exit, B has been overwritten. If JOBVL='V' or JOBVR='V'
      !>          or both, then B contains the second part of the complex
      !>          Schur form of the  versions of the input A and B.
      !>

  [in]

  LDB

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

  [out]

  ALPHA

      !>          ALPHA is COMPLEX array, dimension (N)
      !>

  [out]

  BETA

      !>          BETA is COMPLEX array, dimension (N)
      !>          On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the generalized
      !>          eigenvalues.
      !>
      !>          Note: the quotient ALPHA(j)/BETA(j) ) may easily over- or
      !>          underflow, and BETA(j) may even be zero.  Thus, the user
      !>          should avoid naively computing the ratio ALPHA/BETA.
      !>          However, ALPHA will be always less than and usually
      !>          comparable with norm(A) in magnitude, and BETA always less
      !>          than and usually comparable with norm(B).
      !>

  [out]

  VL

      !>          VL is COMPLEX array, dimension (LDVL,N)
      !>          If JOBVL = 'V', the left generalized eigenvectors u(j) are
      !>          stored one after another in the columns of VL, in the same
      !>          order as their eigenvalues.
      !>          Each eigenvector will be scaled so the largest component
      !>          will have abs(real part) + abs(imag. part) = 1.
      !>          Not referenced if JOBVL = 'N'.
      !>

  [in]

  LDVL

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

  [out]

  VR

      !>          VR is COMPLEX array, dimension (LDVR,N)
      !>          If JOBVR = 'V', the right generalized eigenvectors v(j) are
      !>          stored one after another in the columns of VR, in the same
      !>          order as their eigenvalues.
      !>          Each eigenvector will be scaled so the largest component
      !>          will have abs(real part) + abs(imag. part) = 1.
      !>          Not referenced if JOBVR = 'N'.
      !>

  [in]

  LDVR

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

  [out]

  ILO

      !>          ILO is INTEGER
      !>

  [out]

  IHI

      !>          IHI is INTEGER
      !>          ILO and IHI are integer values such that on exit
      !>          A(i,j) = 0 and B(i,j) = 0 if i > j and
      !>          j = 1,...,ILO-1 or i = IHI+1,...,N.
      !>          If BALANC = 'N' or 'S', ILO = 1 and IHI = N.
      !>

  [out]

  LSCALE

      !>          LSCALE is REAL array, dimension (N)
      !>          Details of the permutations and scaling factors applied
      !>          to the left side of A and B.  If PL(j) is the index of the
      !>          row interchanged with row j, and DL(j) is the scaling
      !>          factor applied to row j, then
      !>            LSCALE(j) = PL(j)  for j = 1,...,ILO-1
      !>                      = DL(j)  for j = ILO,...,IHI
      !>                      = PL(j)  for j = IHI+1,...,N.
      !>          The order in which the interchanges are made is N to IHI+1,
      !>          then 1 to ILO-1.
      !>

  [out]

  RSCALE

      !>          RSCALE is REAL array, dimension (N)
      !>          Details of the permutations and scaling factors applied
      !>          to the right side of A and B.  If PR(j) is the index of the
      !>          column interchanged with column j, and DR(j) is the scaling
      !>          factor applied to column j, then
      !>            RSCALE(j) = PR(j)  for j = 1,...,ILO-1
      !>                      = DR(j)  for j = ILO,...,IHI
      !>                      = PR(j)  for j = IHI+1,...,N
      !>          The order in which the interchanges are made is N to IHI+1,
      !>          then 1 to ILO-1.
      !>

  [out]

  ABNRM

      !>          ABNRM is REAL
      !>          The one-norm of the balanced matrix A.
      !>

  [out]

  BBNRM

      !>          BBNRM is REAL
      !>          The one-norm of the balanced matrix B.
      !>

  [out]

  RCONDE

      !>          RCONDE is REAL array, dimension (N)
      !>          If SENSE = 'E' or 'B', the reciprocal condition numbers of
      !>          the eigenvalues, stored in consecutive elements of the array.
      !>          If SENSE = 'N' or 'V', RCONDE is not referenced.
      !>

  [out]

  RCONDV

      !>          RCONDV is REAL array, dimension (N)
      !>          If SENSE = 'V' or 'B', the estimated reciprocal condition
      !>          numbers of the eigenvectors, stored in consecutive elements
      !>          of the array. If the eigenvalues cannot be reordered to
      !>          compute RCONDV(j), RCONDV(j) is set to 0; this can only occur
      !>          when the true value would be very small anyway.
      !>          If SENSE = 'N' or 'E', RCONDV is not referenced.
      !>

  [out]

  WORK

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

  [in]

  LWORK

      !>          LWORK is INTEGER
      !>          The dimension of the array WORK. LWORK >= max(1,2*N).
      !>          If SENSE = 'E', LWORK >= max(1,4*N).
      !>          If SENSE = 'V' or 'B', LWORK >= max(1,2*N*N+2*N).
      !>
      !>          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.
      !>

  [out]

  RWORK

      !>          RWORK is REAL array, dimension (lrwork)
      !>          lrwork must be at least max(1,6*N) if BALANC = 'S' or 'B',
      !>          and at least max(1,2*N) otherwise.
      !>          Real workspace.
      !>

  [out]

  IWORK

      !>          IWORK is INTEGER array, dimension (N+2)
      !>          If SENSE = 'E', IWORK is not referenced.
      !>

  [out]

  BWORK

      !>          BWORK is LOGICAL array, dimension (N)
      !>          If SENSE = 'N', BWORK is not referenced.
      !>

  [out]

  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:  =N+1: other than QZ iteration failed in CHGEQZ.
      !>                =N+2: error return from CTGEVC.
      !>

Author
  Univ. of Tennessee
  Univ. of California Berkeley
  Univ. of Colorado Denver
  NAG Ltd.

Further Details:

      !>
      !>  Balancing a matrix pair (A,B) includes, first, permuting rows and
      !>  columns to isolate eigenvalues, second, applying diagonal similarity
      !>  transformation to the rows and columns to make the rows and columns
      !>  as close in norm as possible. The computed reciprocal condition
      !>  numbers correspond to the balanced matrix. Permuting rows and columns
      !>  will not change the condition numbers (in exact arithmetic) but
      !>  diagonal scaling will.  For further explanation of balancing, see
      !>  section 4.11.1.2 of LAPACK Users' Guide.
      !>
      !>  An approximate error bound on the chordal distance between the i-th
      !>  computed generalized eigenvalue w and the corresponding exact
      !>  eigenvalue lambda is
      !>
      !>       chord(w, lambda) <= EPS * norm(ABNRM, BBNRM) / RCONDE(I)
      !>
      !>  An approximate error bound for the angle between the i-th computed
      !>  eigenvector VL(i) or VR(i) is given by
      !>
      !>       EPS * norm(ABNRM, BBNRM) / DIF(i).
      !>
      !>  For further explanation of the reciprocal condition numbers RCONDE
      !>  and RCONDV, see section 4.11 of LAPACK User's Guide.
      !>