1ZGEEVX(1)             LAPACK driver routine (version 3.2)            ZGEEVX(1)
2
3
4

NAME

6       ZGEEVX  - computes for an N-by-N complex nonsymmetric matrix A, the ei‐
7       genvalues and, optionally, the left and/or right eigenvectors
8

SYNOPSIS

10       SUBROUTINE ZGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, W, VL, LDVL,
11                          VR,  LDVR,  ILO,  IHI, SCALE, ABNRM, RCONDE, RCONDV,
12                          WORK, LWORK, RWORK, INFO )
13
14           CHARACTER      BALANC, JOBVL, JOBVR, SENSE
15
16           INTEGER        IHI, ILO, INFO, LDA, LDVL, LDVR, LWORK, N
17
18           DOUBLE         PRECISION ABNRM
19
20           DOUBLE         PRECISION RCONDE( * ), RCONDV(  *  ),  RWORK(  *  ),
21                          SCALE( * )
22
23           COMPLEX*16     A(  LDA,  * ), VL( LDVL, * ), VR( LDVR, * ), W( * ),
24                          WORK( * )
25

PURPOSE

27       ZGEEVX computes for an N-by-N complex nonsymmetric matrix A, the eigen‐
28       values and, optionally, the left and/or right eigenvectors.  Optionally
29       also, it computes a balancing transformation to improve the  condition‐
30       ing  of  the eigenvalues and eigenvectors (ILO, IHI, SCALE, and ABNRM),
31       reciprocal condition numbers for the eigenvalues (RCONDE), and recipro‐
32       cal condition numbers for the right
33       eigenvectors (RCONDV).
34       The right eigenvector v(j) of A satisfies
35                        A * v(j) = lambda(j) * v(j)
36       where lambda(j) is its eigenvalue.
37       The left eigenvector u(j) of A satisfies
38                     u(j)**H * A = lambda(j) * u(j)**H
39       where u(j)**H denotes the conjugate transpose of u(j).
40       The  computed  eigenvectors are normalized to have Euclidean norm equal
41       to 1 and largest component real.
42       Balancing a matrix means permuting the rows and columns to make it more
43       nearly upper triangular, and applying a diagonal similarity transforma‐
44       tion D * A * D**(-1), where D is a diagonal matrix, to  make  its  rows
45       and columns closer in norm and the condition numbers of its eigenvalues
46       and eigenvectors smaller.  The computed  reciprocal  condition  numbers
47       correspond to the balanced matrix.  Permuting rows and columns will not
48       change the condition numbers (in exact arithmetic) but diagonal scaling
49       will.   For further explanation of balancing, see section 4.10.2 of the
50       LAPACK Users' Guide.
51

ARGUMENTS

53       BALANC  (input) CHARACTER*1
54               Indicates how the input  matrix  should  be  diagonally  scaled
55               and/or permuted to improve the conditioning of its eigenvalues.
56               = 'N': Do not diagonally scale or permute;
57               = 'P': Perform permutations to  make  the  matrix  more  nearly
58               upper  triangular.  Do  not diagonally scale; = 'S': Diagonally
59               scale the matrix, ie. replace A by D*A*D**(-1), where  D  is  a
60               diagonal  matrix  chosen to make the rows and columns of A more
61               equal in norm. Do not permute; = 'B': Both diagonally scale and
62               permute  A.   Computed reciprocal condition numbers will be for
63               the matrix after balancing and/or permuting. Permuting does not
64               change  condition  numbers (in exact arithmetic), but balancing
65               does.
66
67       JOBVL   (input) CHARACTER*1
68               = 'N': left eigenvectors of A are not computed;
69               = 'V': left eigenvectors of A are computed.  If SENSE = 'E'  or
70               'B', JOBVL must = 'V'.
71
72       JOBVR   (input) CHARACTER*1
73               = 'N': right eigenvectors of A are not computed;
74               = 'V': right eigenvectors of A are computed.  If SENSE = 'E' or
75               'B', JOBVR must = 'V'.
76
77       SENSE   (input) CHARACTER*1
78               Determines which reciprocal condition numbers are computed.   =
79               'N': None are computed;
80               = 'E': Computed for eigenvalues only;
81               = 'V': Computed for right eigenvectors only;
82               =  'B':  Computed  for  eigenvalues and right eigenvectors.  If
83               SENSE = 'E' or 'B', both left and right eigenvectors must  also
84               be computed (JOBVL = 'V' and JOBVR = 'V').
85
86       N       (input) INTEGER
87               The order of the matrix A. N >= 0.
88
89       A       (input/output) COMPLEX*16 array, dimension (LDA,N)
90               On  entry,  the N-by-N matrix A.  On exit, A has been overwrit‐
91               ten.  If JOBVL = 'V' or JOBVR = 'V', A contains the Schur  form
92               of the balanced version of the matrix A.
93
94       LDA     (input) INTEGER
95               The leading dimension of the array A.  LDA >= max(1,N).
96
97       W       (output) COMPLEX*16 array, dimension (N)
98               W contains the computed eigenvalues.
99
100       VL      (output) COMPLEX*16 array, dimension (LDVL,N)
101               If JOBVL = 'V', the left eigenvectors u(j) are stored one after
102               another in the columns of VL, in the same order as their eigen‐
103               values.  If JOBVL = 'N', VL is not referenced.  u(j) = VL(:,j),
104               the j-th column of VL.
105
106       LDVL    (input) INTEGER
107               The leading dimension of the array VL.  LDVL >= 1; if  JOBVL  =
108               'V', LDVL >= N.
109
110       VR      (output) COMPLEX*16 array, dimension (LDVR,N)
111               If  JOBVR  =  'V',  the  right eigenvectors v(j) are stored one
112               after another in the columns of VR, in the same order as  their
113               eigenvalues.   If  JOBVR  =  'N', VR is not referenced.  v(j) =
114               VR(:,j), the j-th column of VR.
115
116       LDVR    (input) INTEGER
117               The leading dimension of the array VR.  LDVR >= 1; if  JOBVR  =
118               'V', LDVR >= N.
119
120       ILO     (output) INTEGER
121               IHI      (output) INTEGER ILO and IHI are integer values deter‐
122               mined when A was balanced.  The balanced A(i,j) = 0 if  I  >  J
123               and J = 1,...,ILO-1 or I = IHI+1,...,N.
124
125       SCALE   (output) DOUBLE PRECISION array, dimension (N)
126               Details  of  the  permutations and scaling factors applied when
127               balancing A.  If P(j) is the index of the row and column inter‐
128               changed  with  row and column j, and D(j) is the scaling factor
129               applied to row and column j, then SCALE(J) = P(J),    for  J  =
130               1,...,ILO-1  =  D(J),    for J = ILO,...,IHI = P(J)     for J =
131               IHI+1,...,N.  The order in which the interchanges are made is N
132               to IHI+1, then 1 to ILO-1.
133
134       ABNRM   (output) DOUBLE PRECISION
135               The  one-norm of the balanced matrix (the maximum of the sum of
136               absolute values of elements of any column).
137
138       RCONDE  (output) DOUBLE PRECISION array, dimension (N)
139               RCONDE(j) is the reciprocal condition number of the j-th eigen‐
140               value.
141
142       RCONDV  (output) DOUBLE PRECISION array, dimension (N)
143               RCONDV(j)  is the reciprocal condition number of the j-th right
144               eigenvector.
145
146       WORK    (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK))
147               On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
148
149       LWORK   (input) INTEGER
150               The dimension of the array WORK.  If SENSE = 'N' or 'E',  LWORK
151               >=  max(1,2*N),  and  if  SENSE = 'V' or 'B', LWORK >= N*N+2*N.
152               For good performance, LWORK must generally be larger.  If LWORK
153               =  -1, then a workspace query is assumed; the routine only cal‐
154               culates the optimal size of the WORK array, returns this  value
155               as  the  first  entry  of  the WORK array, and no error message
156               related to LWORK is issued by XERBLA.
157
158       RWORK   (workspace) DOUBLE PRECISION array, dimension (2*N)
159
160       INFO    (output) INTEGER
161               = 0:  successful exit
162               < 0:  if INFO = -i, the i-th argument had an illegal value.
163               > 0:  if INFO = i, the QR algorithm failed to compute  all  the
164               eigenvalues, and no eigenvectors or condition numbers have been
165               computed; elements 1:ILO-1 and i+1:N of W  contain  eigenvalues
166               which have converged.
167
168
169
170 LAPACK driver routine (version 3.N2o)vember 2008                       ZGEEVX(1)
Impressum