[ новости /+++ | форум | теги | ]

NAME
     ctgevc - compute some or all of the right and/or  left  gen-
     eralized  eigenvectors of a pair of complex upper triangular
     matrices (A,B)

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

     CHARACTER HOWMNY, SIDE

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

     LOGICAL SELECT( * )

     REAL RWORK( * )

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



     #include <sunperf.h>

     void ctgevc(char side, char howmny, int *select, int n, com-
               plex  *ca,  int lda, complex *cb, int ldb, complex
               *vl, int ldvl, complex *vr, int ldvr, int mm,  int
               *m, int *info) ;

PURPOSE
     CTGEVC computes some or all of the right  and/or  left  gen-
     eralized  eigenvectors of a pair of complex upper triangular
     matrices (A,B).

     The right generalized eigenvector x and the left generalized
     eigenvector y of (A,B) corresponding to a generalized eigen-
     value w are defined by:

             (A - wB) * x = 0  and  y**H * (A - wB) = 0

     where y**H denotes the conjugate tranpose of y.

     If an eigenvalue w is determined by zero  diagonal  elements
     of  both  A  and  B,  a  unit  vector  is  returned  as  the
     corresponding eigenvector.

     If all eigenvectors are requested, the  routine  may  either
     return the matrices X and/or Y of right or left eigenvectors
     of (A,B), or the products Z*X and/or Q*Y, where Z and Q  are
     input unitary matrices.  If (A,B) was obtained from the gen-
     eralized Schur factorization of an original pair of matrices
        (A0,B0) = (Q*A*Z**H,Q*B*Z**H),

     then Z*X and Q*Y are the matrices of right or left eigenvec-
     tors of A.


ARGUMENTS
     SIDE      (input) CHARACTER*1
               = 'R': compute right eigenvectors only;
               = 'L': compute left eigenvectors only;
               = 'B': compute both right and left eigenvectors.

     HOWMNY    (input) CHARACTER*1
               = 'A': compute all right and/or left eigenvectors;
               = 'B': compute all right and/or left eigenvectors,
               and  backtransform  them  using the input matrices
               supplied in VR and/or VL; = 'S': compute  selected
               right  and/or  left eigenvectors, specified by the
               logical array SELECT.

     SELECT    (input) LOGICAL array, dimension (N)
               If HOWMNY='S', SELECT specifies  the  eigenvectors
               to  be  computed.  If HOWMNY='A' or 'B', SELECT is
               not  referenced.   To   select   the   eigenvector
               corresponding  to  the  j-th eigenvalue, SELECT(j)
               must be set to .TRUE..

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

     A         (input) COMPLEX array, dimension (LDA,N)
               The upper triangular matrix A.

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

     B         (input) COMPLEX array, dimension (LDB,N)
               The upper triangular matrix B.  B must  have  real
               diagonal elements.

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

     VL        (input/output) COMPLEX 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
               unitary matrix Q of left Schur vectors returned by
               CHGEQZ).   On  exit, if SIDE = 'L' or 'B', VL con-
               tains:  if HOWMNY = 'A',  the  matrix  Y  of  left
               eigenvectors of (A,B); if HOWMNY = 'B', the matrix
               Q*Y; if HOWMNY = 'S',  the  left  eigenvectors  of
               (A,B) specified by SELECT, stored consecutively in
               the columns of VL, in  the  same  order  as  their
               eigenvalues.  If SIDE = 'R', VL is not referenced.

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

     VR        (input/output) COMPLEX array, dimension (LDVR,MM)
               On entry, if SIDE = 'R' or 'B' and HOWMNY  =  'B',
               VR  must  contain  an N-by-N matrix Q (usually the
               unitary matrix Z of right Schur  vectors  returned
               by  CHGEQZ).   On  exit,  if SIDE = 'R' or 'B', VR
               contains:  if HOWMNY = 'A', the matrix X of  right
               eigenvectors of (A,B); if HOWMNY = 'B', the matrix
               Z*X; if HOWMNY = 'S', the  right  eigenvectors  of
               (A,B) specified by SELECT, stored consecutively in
               the columns of VR, in  the  same  order  as  their
               eigenvalues.  If SIDE = 'L', VR is not referenced.

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

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

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

     M         (output) 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
               eigenvector occupies one column.

     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 ille-
               gal value.

Партнёры:

Хостинг: