1ZHEGVD(1)             LAPACK driver routine (version 3.1)            ZHEGVD(1)
2
3
4

NAME

6       ZHEGVD  -  all  the  eigenvalues, and optionally, the eigenvectors of a
7       complex  generalized  Hermitian-definite  eigenproblem,  of  the   form
8       A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x
9

SYNOPSIS

11       SUBROUTINE ZHEGVD( ITYPE,  JOBZ,  UPLO,  N,  A,  LDA,  B, LDB, W, WORK,
12                          LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO )
13
14           CHARACTER      JOBZ, UPLO
15
16           INTEGER        INFO, ITYPE, LDA, LDB, LIWORK, LRWORK, LWORK, N
17
18           INTEGER        IWORK( * )
19
20           DOUBLE         PRECISION RWORK( * ), W( * )
21
22           COMPLEX*16     A( LDA, * ), B( LDB, * ), WORK( * )
23

PURPOSE

25       ZHEGVD computes all the eigenvalues, and optionally,  the  eigenvectors
26       of  a  complex generalized Hermitian-definite eigenproblem, of the form
27       A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and B
28       are assumed to be Hermitian and B is also positive definite.  If eigen‐
29       vectors are desired, it uses a divide and conquer algorithm.
30
31       The divide and conquer algorithm  makes  very  mild  assumptions  about
32       floating  point arithmetic. It will work on machines with a guard digit
33       in add/subtract, or on those binary machines without guard digits which
34       subtract  like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could
35       conceivably fail on hexadecimal or decimal machines without guard  dig‐
36       its, but we know of none.
37
38

ARGUMENTS

40       ITYPE   (input) INTEGER
41               Specifies the problem type to be solved:
42               = 1:  A*x = (lambda)*B*x
43               = 2:  A*B*x = (lambda)*x
44               = 3:  B*A*x = (lambda)*x
45
46       JOBZ    (input) CHARACTER*1
47               = 'N':  Compute eigenvalues only;
48               = 'V':  Compute eigenvalues and eigenvectors.
49
50       UPLO    (input) CHARACTER*1
51               = 'U':  Upper triangles of A and B are stored;
52               = 'L':  Lower triangles of A and B are stored.
53
54       N       (input) INTEGER
55               The order of the matrices A and B.  N >= 0.
56
57       A       (input/output) COMPLEX*16 array, dimension (LDA, N)
58               On  entry,  the Hermitian matrix A.  If UPLO = 'U', the leading
59               N-by-N upper triangular part of A contains the upper triangular
60               part  of the matrix A.  If UPLO = 'L', the leading N-by-N lower
61               triangular part of A contains the lower triangular part of  the
62               matrix A.
63
64               On exit, if JOBZ = 'V', then if INFO = 0, A contains the matrix
65               Z of eigenvectors.  The eigenvectors are normalized as follows:
66               if  ITYPE = 1 or 2, Z**H*B*Z = I; if ITYPE = 3, Z**H*inv(B)*Z =
67               I.  If JOBZ  =  'N',  then  on  exit  the  upper  triangle  (if
68               UPLO='U')  or  the lower triangle (if UPLO='L') of A, including
69               the diagonal, is destroyed.
70
71       LDA     (input) INTEGER
72               The leading dimension of the array A.  LDA >= max(1,N).
73
74       B       (input/output) COMPLEX*16 array, dimension (LDB, N)
75               On entry, the Hermitian matrix B.  If UPLO = 'U',  the  leading
76               N-by-N upper triangular part of B contains the upper triangular
77               part of the matrix B.  If UPLO = 'L', the leading N-by-N  lower
78               triangular  part of B contains the lower triangular part of the
79               matrix B.
80
81               On exit, if INFO <= N, the part of B containing the  matrix  is
82               overwritten  by  the triangular factor U or L from the Cholesky
83               factorization B = U**H*U or B = L*L**H.
84
85       LDB     (input) INTEGER
86               The leading dimension of the array B.  LDB >= max(1,N).
87
88       W       (output) DOUBLE PRECISION array, dimension (N)
89               If INFO = 0, the eigenvalues in ascending order.
90
91       WORK    (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK))
92               On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
93
94       LWORK   (input) INTEGER
95               The length of the array WORK.  If N <= 1,                 LWORK
96               >=  1.   If  JOBZ  = 'N' and N > 1, LWORK >= N + 1.  If JOBZ  =
97               'V' and N > 1, LWORK >= 2*N + N**2.
98
99               If LWORK = -1, then a workspace query is assumed;  the  routine
100               only  calculates the optimal sizes of the WORK, RWORK and IWORK
101               arrays, returns these values as the first entries of the  WORK,
102               RWORK  and  IWORK arrays, and no error message related to LWORK
103               or LRWORK or LIWORK is issued by XERBLA.
104
105       RWORK     (workspace/output)   DOUBLE   PRECISION   array,    dimension
106       (MAX(1,LRWORK))
107               On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
108
109       LRWORK  (input) INTEGER
110               The   dimension   of   the   array   RWORK.    If   N   <=   1,
111               LRWORK >= 1.  If JOBZ  = 'N' and N > 1, LRWORK >= N.   If  JOBZ
112               = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.
113
114               If  LRWORK = -1, then a workspace query is assumed; the routine
115               only calculates the optimal sizes of the WORK, RWORK and  IWORK
116               arrays,  returns these values as the first entries of the WORK,
117               RWORK and IWORK arrays, and no error message related  to  LWORK
118               or LRWORK or LIWORK is issued by XERBLA.
119
120       IWORK   (workspace/output) INTEGER array, dimension (MAX(1,LIWORK))
121               On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
122
123       LIWORK  (input) INTEGER
124               The   dimension   of   the   array   IWORK.    If   N   <=   1,
125               LIWORK >= 1.  If JOBZ  = 'N' and N > 1, LIWORK >= 1.   If  JOBZ
126               = 'V' and N > 1, LIWORK >= 3 + 5*N.
127
128               If  LIWORK = -1, then a workspace query is assumed; the routine
129               only calculates the optimal sizes of the WORK, RWORK and  IWORK
130               arrays,  returns these values as the first entries of the WORK,
131               RWORK and IWORK arrays, and no error message related  to  LWORK
132               or LRWORK or LIWORK is issued by XERBLA.
133
134       INFO    (output) INTEGER
135               = 0:  successful exit
136               < 0:  if INFO = -i, the i-th argument had an illegal value
137               > 0:  ZPOTRF or ZHEEVD returned an error code:
138               <= N:  if INFO = i and JOBZ = 'N', then the algorithm failed to
139               converge; i off-diagonal elements of an intermediate  tridiago‐
140               nal  form did not converge to zero; if INFO = i and JOBZ = 'V',
141               then the algorithm failed to compute an eigenvalue while  work‐
142               ing  on  the  submatrix  lying  in  rows and columns INFO/(N+1)
143               through mod(INFO,N+1); > N:   if INFO = N + i, for 1 <= i <= N,
144               then  the  leading  minor of order i of B is not positive defi‐
145               nite.  The factorization of B could not be completed and no ei‐
146               genvalues or eigenvectors were computed.
147

FURTHER DETAILS

149       Based on contributions by
150          Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA
151
152       Modified  so  that  no backsubstitution is performed if ZHEEVD fails to
153       converge (NEIG in old code could be  greater  than  N  causing  out  of
154       bounds  reference  to  A - reported by Ralf Meyer).  Also corrected the
155       description of INFO and the test on ITYPE. Sven, 16 Feb 05.
156
157
158
159 LAPACK driver routine (version 3.N1o)vember 2006                       ZHEGVD(1)
Impressum