Previous: ctbtrs Up: ../lapack-c.html Next: ctgsja


ctgevc


 NAME
      CTGEVC - compute selected left and/or right generalized
      eigenvectors of a pair of complex upper triangular matrices
      (A,B)

 SYNOPSIS
      SUBROUTINE CTGEVC( JOB, SIDE, SELECT, N, A, LDA, B, LDB, VL,
                         LDVL, VR, LDVR, MM, M, WORK, RWORK, INFO
                         )

          CHARACTER      JOB, SIDE

          INTEGER        INFO, LDA, LDB, LDVL, LDVR, M, MM, N

          LOGICAL        SELECT( * )

          REAL           RWORK( N, * )

          COMPLEX        A( LDA, * ), B( LDB, * ), VL( LDVL, * ),
                         VR( LDVR, * ), WORK( N, * )

 PURPOSE
      CTGEVC computes selected left and/or right generalized
      eigenvectors of a pair of complex upper triangular matrices
      (A,B).  The j-th generalized left and right eigenvectors are
      y  and  x, resp., such that:
              H
             y  (A - wB) = 0       (A - wB)x = 0

                                                                          H
      Note: the left eigenvector is sometimes defined as the row
      vector  y
            but CTGEVC computes the column vector y.

 ARGUMENTS
      JOB     (input) CHARACTER*1
              = 'A': compute All (left/right/left+right) general-
              ized eigenvectors of (A,B); = 'S': compute Selected
              (left/right/left+right) generalized eigenvectors of
              (A,B) -- see the description of the argument SELECT;
              = 'B' or 'T': compute all (left/right/left+right)
              generalized eigenvectors of (A,B), and Back
              Transform them using the initial contents of VL/VR
              -- see the descriptions of the arguments VL and VR.

      SIDE    (input) CHARACTER*1
              Specifies for which side eigenvectors are to be com-
              puted:
              = 'R': compute right eigenvectors only;
              = 'L': compute left eigenvectors only;
              = 'B': compute both right and left eigenvectors.

      SELECT  (input) LOGICAL array, dimension (N)
              If JOB='S', then SELECT specifies the (generalized)
              eigenvectors to be computed.  To get the eigenvector
              corresponding to the j-th eigenvalue, set SELECT(j)
              to .TRUE..  If JOB='A', 'B', or 'T', SELECT is not
              referenced, and all eigenvectors are selected.

      N       (input) INTEGER
              The order of the matrices A and B.  N >= 0.

      A       (input) COMPLEX array, dimension (LDA,N)
              One of the pair of matrices whose generalized eigen-
              vectors are to be computed.  It must be upper tri-
              angular.

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

      B       (input) COMPLEX array, dimension (LDB,N)
              The other of the pair of matrices whose generalized
              eigenvectors are to be computed.  It must be upper
              triangular with real diagonal elements.

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

      VL      (input/output) COMPLEX array, dimension (LDVL,MM)
              The left eigenvectors (column vectors -- see the
              note in "Purpose".) If JOB='A', then all left eigen-
              vectors of (A,B) will be computed and stored in VL.
              If JOB='S', then only the eigenvectors selected by
              SELECT will be computed; the first selected eigen-
              vector will go in column 1, the second in column 2,
              etc.  If JOB='B' or 'T', then all left eigenvectors
              of (A,B) will be computed and multiplied (on the
              left) by the matrix found in VL on entry to CTGEVC.
              Usually, this will be the Q matrix computed by
              CGGHRD and CHGEQZ, so that on exit, VL will contain
              the left eigenvectors of the original matrix pair.
              In any case, each eigenvector will be scaled so the
              largest component of each vector has abs(real part)
              + abs(imag. part)=1, *unless*  A and B both have a
              zero in the diagonal entry corresponding to the
              eigenvector, in which case the eigenvector will be
              zero.  If SIDE = 'R', VL is not referenced.

      LDVL    (input) INTEGER
              The leading dimension of array VL.  LDVL >= 1; if
              SIDE = 'B' or 'L', LDVL >= N.

      VR      (input/output) COMPLEX array, dimension (LDVR,MM)
              The right eigenvectors.  If JOB='A', then all right

              eigenvectors of (A,B) will be computed and stored in
              VR.  If JOB='S', then only the eigenvectors selected
              by SELECT will be computed; the first selected
              eigenvector will go in column 1, the second in
              column 2, etc.  If JOB='B' or 'T', then all right
              eigenvectors of (A,B) will be computed and multi-
              plied (on the left) by the matrix found in VR on
              entry to CTGEVC.  Usually, this will be the Z matrix
              computed by CGGHRD and CHGEQZ, so that on exit, VR
              will contain the right eigenvectors of the original
              matrix pair.  In any case, each eigenvector will be
              scaled so the largest component of each vector has
              abs(real part) + abs(imag. part)=1, *unless*  A and
              B both have a zero in the diagonal entry correspond-
              ing to the eigenvector, in which case the eigenvec-
              tor will be zero.  If SIDE = 'L', VR is not refer-
              enced.

      LDVR    (input) INTEGER
              The leading dimension of array VR.  LDVR >= 1; if
              SIDE = 'B' or 'R', LDVR >= N.

      MM      (input) INTEGER
              The number of columns in VL and/or VR.  If JOB='A',
              'B', or 'T', then MM >= N.  If JOB='S', then MM must
              be at least the number of .TRUE.  values in
              SELECT(1:N).

      M       (output) INTEGER
              The number of columns in VL and/or VR actually used
              to store the eigenvectors.

      WORK    (workspace) COMPLEX array, dimension ( 2, N )

      RWORK   (workspace) REAL array, dimension ( 2, N )

      INFO    (output) INTEGER
              = 0:  successful exit.
              < 0:  if INFO = -i, the i-th argument had an illegal
              value.