SysTutorials

Linux Manual Pages › Section 3

stgevc-f(3)

stgevc.f –

Synopsis

Functions/Subroutines

subroutine stgevc (SIDE, HOWMNY, SELECT, N, S, LDS, P, LDP, VL, LDVL, VR, LDVR, MM, M, WORK, INFO)
STGEVC

Function/Subroutine Documentation

subroutine stgevc (characterSIDE, characterHOWMNY, logical, dimension( * )SELECT, integerN, real, dimension( lds, * )S, integerLDS, real, dimension( ldp, * )P, integerLDP, real, dimension( ldvl, * )VL, integerLDVL, real, dimension( ldvr, * )VR, integerLDVR, integerMM, integerM, real, dimension( * )WORK, integerINFO)

STGEVC

Purpose:

 STGEVC computes some or all of the right and/or left eigenvectors of
 a pair of real matrices (S,P), where S is a quasi-triangular matrix
 and P is upper triangular. Matrix pairs of this type are produced by
 the generalized Schur factorization of a matrix pair (A,B):
 A = Q*S*Z**T, B = Q*P*Z**T
 as computed by SGGHRD + SHGEQZ.
 The right eigenvector x and the left eigenvector y of (S,P)
 corresponding to an eigenvalue w are defined by:
 S*x = w*P*x, (y**H)*S = w*(y**H)*P,
 where y**H denotes the conjugate tranpose of y.
 The eigenvalues are not input to this routine, but are computed
 directly from the diagonal blocks of S and P.
 This routine returns the matrices X and/or Y of right and left
 eigenvectors of (S,P), or the products Z*X and/or Q*Y,
 where Z and Q are input matrices.
 If Q and Z are the orthogonal factors from the generalized Schur
 factorization of a matrix pair (A,B), then Z*X and Q*Y
 are the matrices of right and left eigenvectors of (A,B).

 

Parameters:

SIDE
 SIDE is CHARACTER*1
 = 'R': compute right eigenvectors only;
 = 'L': compute left eigenvectors only;
 = 'B': compute both right and left eigenvectors.

HOWMNY

 HOWMNY is CHARACTER*1
 = 'A': compute all right and/or left eigenvectors;
 = 'B': compute all right and/or left eigenvectors,
 backtransformed by the matrices in VR and/or VL;
 = 'S': compute selected right and/or left eigenvectors,
 specified by the logical array SELECT.

SELECT

 SELECT is LOGICAL array, dimension (N)
 If HOWMNY='S', SELECT specifies the eigenvectors to be
 computed. If w(j) is a real eigenvalue, the corresponding
 real eigenvector is computed if SELECT(j) is .TRUE..
 If w(j) and w(j+1) are the real and imaginary parts of a
 complex eigenvalue, the corresponding complex eigenvector
 is computed if either SELECT(j) or SELECT(j+1) is .TRUE.,
 and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is
 set to .FALSE..
 Not referenced if HOWMNY = 'A' or 'B'.

N

 N is INTEGER
 The order of the matrices S and P. N >= 0.

S

 S is REAL array, dimension (LDS,N)
 The upper quasi-triangular matrix S from a generalized Schur
 factorization, as computed by SHGEQZ.

LDS

 LDS is INTEGER
 The leading dimension of array S. LDS >= max(1,N).

P

 P is REAL array, dimension (LDP,N)
 The upper triangular matrix P from a generalized Schur
 factorization, as computed by SHGEQZ.
 2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks
 of S must be in positive diagonal form.

LDP

 LDP is INTEGER
 The leading dimension of array P. LDP >= max(1,N).

VL

 VL is REAL array, dimension (LDVL,MM)
 On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must
 contain an N-by-N matrix Q (usually the orthogonal matrix Q
 of left Schur vectors returned by SHGEQZ).
 On exit, if SIDE = 'L' or 'B', VL contains:
 if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P);
 if HOWMNY = 'B', the matrix Q*Y;
 if HOWMNY = 'S', the left eigenvectors of (S,P) specified by
 SELECT, stored consecutively in the columns of
 VL, in the same order as their eigenvalues.
 A complex eigenvector corresponding to a complex eigenvalue
 is stored in two consecutive columns, the first holding the
 real part, and the second the imaginary part.
 Not referenced if SIDE = 'R'.

LDVL

 LDVL is INTEGER
 The leading dimension of array VL. LDVL >= 1, and if
 SIDE = 'L' or 'B', LDVL >= N.

VR

 VR is REAL array, dimension (LDVR,MM)
 On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must
 contain an N-by-N matrix Z (usually the orthogonal matrix Z
 of right Schur vectors returned by SHGEQZ).
 On exit, if SIDE = 'R' or 'B', VR contains:
 if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P);
 if HOWMNY = 'B' or 'b', the matrix Z*X;
 if HOWMNY = 'S' or 's', the right eigenvectors of (S,P)
 specified by SELECT, stored consecutively in the
 columns of VR, in the same order as their
 eigenvalues.
 A complex eigenvector corresponding to a complex eigenvalue
 is stored in two consecutive columns, the first holding the
 real part and the second the imaginary part.
 Not referenced if SIDE = 'L'.

LDVR

 LDVR is INTEGER
 The leading dimension of the array VR. LDVR >= 1, and if
 SIDE = 'R' or 'B', LDVR >= N.

MM

 MM is INTEGER
 The number of columns in the arrays VL and/or VR. MM >= M.

M

 M is INTEGER
 The number of columns in the arrays VL and/or VR actually
 used to store the eigenvectors. If HOWMNY = 'A' or 'B', M
 is set to N. Each selected real eigenvector occupies one
 column and each selected complex eigenvector occupies two
 columns.

WORK

 WORK is REAL array, dimension (6*N)

INFO

 INFO is INTEGER
 = 0: successful exit.
 < 0: if INFO = -i, the i-th argument had an illegal value.
 > 0: the 2-by-2 block (INFO:INFO+1) does not have a complex
 eigenvalue.

 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Further Details:

 Allocation of workspace:
 ---------- -- ---------
 WORK( j ) = 1-norm of j-th column of A, above the diagonal
 WORK( N+j ) = 1-norm of j-th column of B, above the diagonal
 WORK( 2*N+1:3*N ) = real part of eigenvector
 WORK( 3*N+1:4*N ) = imaginary part of eigenvector
 WORK( 4*N+1:5*N ) = real part of back-transformed eigenvector
 WORK( 5*N+1:6*N ) = imaginary part of back-transformed eigenvector
 Rowwise vs. columnwise solution methods:
 ------- -- ---------- -------- -------
 Finding a generalized eigenvector consists basically of solving the
 singular triangular system
 (A - w B) x = 0 (for right) or: (A - w B)**H y = 0 (for left)
 Consider finding the i-th right eigenvector (assume all eigenvalues
 are real). The equation to be solved is:
 n i
 0 = sum C(j,k) v(k) = sum C(j,k) v(k) for j = i,. . .,1
 k=j k=j
 where C = (A - w B) (The components v(i+1:n) are 0.)
 The "rowwise" method is:
 (1) v(i) := 1
 for j = i-1,. . .,1:
 i
 (2) compute s = - sum C(j,k) v(k) and
 k=j+1
 (3) v(j) := s / C(j,j)
 Step 2 is sometimes called the "dot product" step, since it is an
 inner product between the j-th row and the portion of the eigenvector
 that has been computed so far.
 The "columnwise" method consists basically in doing the sums
 for all the rows in parallel. As each v(j) is computed, the
 contribution of v(j) times the j-th column of C is added to the
 partial sums. Since FORTRAN arrays are stored columnwise, this has
 the advantage that at each step, the elements of C that are accessed
 are adjacent to one another, whereas with the rowwise method, the
 elements accessed at a step are spaced LDS (and LDP) words apart.
 When finding left eigenvectors, the matrix in question is the
 transpose of the one in storage, so the rowwise method then
 actually accesses columns of A and B at each step, and so is the
 preferred method.

 

Definition at line 295 of file stgevc.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.