LAPACK  3.10.0 LAPACK: Linear Algebra PACKage
zheevx_2stage.f
Go to the documentation of this file.
1 *> \brief <b> ZHEEVX_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices</b>
2 *
3 * @precisions fortran z -> s d c
4 *
5 * =========== DOCUMENTATION ===========
6 *
7 * Online html documentation available at
8 * http://www.netlib.org/lapack/explore-html/
9 *
10 *> \htmlonly
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zheevx_2stage.f">
13 *> [TGZ]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zheevx_2stage.f">
15 *> [ZIP]</a>
16 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevx_2stage.f">
17 *> [TXT]</a>
18 *> \endhtmlonly
19 *
20 * Definition:
21 * ===========
22 *
23 * SUBROUTINE ZHEEVX_2STAGE( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU,
24 * IL, IU, ABSTOL, M, W, Z, LDZ, WORK,
25 * LWORK, RWORK, IWORK, IFAIL, INFO )
26 *
27 * IMPLICIT NONE
28 *
29 * .. Scalar Arguments ..
30 * CHARACTER JOBZ, RANGE, UPLO
31 * INTEGER IL, INFO, IU, LDA, LDZ, LWORK, M, N
32 * DOUBLE PRECISION ABSTOL, VL, VU
33 * ..
34 * .. Array Arguments ..
35 * INTEGER IFAIL( * ), IWORK( * )
36 * DOUBLE PRECISION RWORK( * ), W( * )
37 * COMPLEX*16 A( LDA, * ), WORK( * ), Z( LDZ, * )
38 * ..
39 *
40 *
41 *> \par Purpose:
42 * =============
43 *>
44 *> \verbatim
45 *>
46 *> ZHEEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors
47 *> of a complex Hermitian matrix A using the 2stage technique for
48 *> the reduction to tridiagonal. Eigenvalues and eigenvectors can
49 *> be selected by specifying either a range of values or a range of
50 *> indices for the desired eigenvalues.
51 *> \endverbatim
52 *
53 * Arguments:
54 * ==========
55 *
56 *> \param[in] JOBZ
57 *> \verbatim
58 *> JOBZ is CHARACTER*1
59 *> = 'N': Compute eigenvalues only;
60 *> = 'V': Compute eigenvalues and eigenvectors.
61 *> Not available in this release.
62 *> \endverbatim
63 *>
64 *> \param[in] RANGE
65 *> \verbatim
66 *> RANGE is CHARACTER*1
67 *> = 'A': all eigenvalues will be found.
68 *> = 'V': all eigenvalues in the half-open interval (VL,VU]
69 *> will be found.
70 *> = 'I': the IL-th through IU-th eigenvalues will be found.
71 *> \endverbatim
72 *>
73 *> \param[in] UPLO
74 *> \verbatim
75 *> UPLO is CHARACTER*1
76 *> = 'U': Upper triangle of A is stored;
77 *> = 'L': Lower triangle of A is stored.
78 *> \endverbatim
79 *>
80 *> \param[in] N
81 *> \verbatim
82 *> N is INTEGER
83 *> The order of the matrix A. N >= 0.
84 *> \endverbatim
85 *>
86 *> \param[in,out] A
87 *> \verbatim
88 *> A is COMPLEX*16 array, dimension (LDA, N)
89 *> On entry, the Hermitian matrix A. If UPLO = 'U', the
90 *> leading N-by-N upper triangular part of A contains the
91 *> upper triangular part of the matrix A. If UPLO = 'L',
92 *> the leading N-by-N lower triangular part of A contains
93 *> the lower triangular part of the matrix A.
94 *> On exit, the lower triangle (if UPLO='L') or the upper
95 *> triangle (if UPLO='U') of A, including the diagonal, is
96 *> destroyed.
97 *> \endverbatim
98 *>
99 *> \param[in] LDA
100 *> \verbatim
101 *> LDA is INTEGER
102 *> The leading dimension of the array A. LDA >= max(1,N).
103 *> \endverbatim
104 *>
105 *> \param[in] VL
106 *> \verbatim
107 *> VL is DOUBLE PRECISION
108 *> If RANGE='V', the lower bound of the interval to
109 *> be searched for eigenvalues. VL < VU.
110 *> Not referenced if RANGE = 'A' or 'I'.
111 *> \endverbatim
112 *>
113 *> \param[in] VU
114 *> \verbatim
115 *> VU is DOUBLE PRECISION
116 *> If RANGE='V', the upper bound of the interval to
117 *> be searched for eigenvalues. VL < VU.
118 *> Not referenced if RANGE = 'A' or 'I'.
119 *> \endverbatim
120 *>
121 *> \param[in] IL
122 *> \verbatim
123 *> IL is INTEGER
124 *> If RANGE='I', the index of the
125 *> smallest eigenvalue to be returned.
126 *> 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.
127 *> Not referenced if RANGE = 'A' or 'V'.
128 *> \endverbatim
129 *>
130 *> \param[in] IU
131 *> \verbatim
132 *> IU is INTEGER
133 *> If RANGE='I', the index of the
134 *> largest eigenvalue to be returned.
135 *> 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.
136 *> Not referenced if RANGE = 'A' or 'V'.
137 *> \endverbatim
138 *>
139 *> \param[in] ABSTOL
140 *> \verbatim
141 *> ABSTOL is DOUBLE PRECISION
142 *> The absolute error tolerance for the eigenvalues.
143 *> An approximate eigenvalue is accepted as converged
144 *> when it is determined to lie in an interval [a,b]
145 *> of width less than or equal to
146 *>
147 *> ABSTOL + EPS * max( |a|,|b| ) ,
148 *>
149 *> where EPS is the machine precision. If ABSTOL is less than
150 *> or equal to zero, then EPS*|T| will be used in its place,
151 *> where |T| is the 1-norm of the tridiagonal matrix obtained
152 *> by reducing A to tridiagonal form.
153 *>
154 *> Eigenvalues will be computed most accurately when ABSTOL is
155 *> set to twice the underflow threshold 2*DLAMCH('S'), not zero.
156 *> If this routine returns with INFO>0, indicating that some
157 *> eigenvectors did not converge, try setting ABSTOL to
158 *> 2*DLAMCH('S').
159 *>
160 *> See "Computing Small Singular Values of Bidiagonal Matrices
161 *> with Guaranteed High Relative Accuracy," by Demmel and
162 *> Kahan, LAPACK Working Note #3.
163 *> \endverbatim
164 *>
165 *> \param[out] M
166 *> \verbatim
167 *> M is INTEGER
168 *> The total number of eigenvalues found. 0 <= M <= N.
169 *> If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.
170 *> \endverbatim
171 *>
172 *> \param[out] W
173 *> \verbatim
174 *> W is DOUBLE PRECISION array, dimension (N)
175 *> On normal exit, the first M elements contain the selected
176 *> eigenvalues in ascending order.
177 *> \endverbatim
178 *>
179 *> \param[out] Z
180 *> \verbatim
181 *> Z is COMPLEX*16 array, dimension (LDZ, max(1,M))
182 *> If JOBZ = 'V', then if INFO = 0, the first M columns of Z
183 *> contain the orthonormal eigenvectors of the matrix A
184 *> corresponding to the selected eigenvalues, with the i-th
185 *> column of Z holding the eigenvector associated with W(i).
186 *> If an eigenvector fails to converge, then that column of Z
187 *> contains the latest approximation to the eigenvector, and the
188 *> index of the eigenvector is returned in IFAIL.
189 *> If JOBZ = 'N', then Z is not referenced.
190 *> Note: the user must ensure that at least max(1,M) columns are
191 *> supplied in the array Z; if RANGE = 'V', the exact value of M
192 *> is not known in advance and an upper bound must be used.
193 *> \endverbatim
194 *>
195 *> \param[in] LDZ
196 *> \verbatim
197 *> LDZ is INTEGER
198 *> The leading dimension of the array Z. LDZ >= 1, and if
199 *> JOBZ = 'V', LDZ >= max(1,N).
200 *> \endverbatim
201 *>
202 *> \param[out] WORK
203 *> \verbatim
204 *> WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
205 *> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
206 *> \endverbatim
207 *>
208 *> \param[in] LWORK
209 *> \verbatim
210 *> LWORK is INTEGER
211 *> The length of the array WORK. LWORK >= 1, when N <= 1;
212 *> otherwise
213 *> If JOBZ = 'N' and N > 1, LWORK must be queried.
214 *> LWORK = MAX(1, 8*N, dimension) where
215 *> dimension = max(stage1,stage2) + (KD+1)*N + N
216 *> = N*KD + N*max(KD+1,FACTOPTNB)
218 *> + (KD+1)*N + N
219 *> where KD is the blocking size of the reduction,
220 *> FACTOPTNB is the blocking used by the QR or LQ
221 *> algorithm, usually FACTOPTNB=128 is a good choice
223 *> openMP compilation is enabled, otherwise =1.
224 *> If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available
225 *>
226 *> If LWORK = -1, then a workspace query is assumed; the routine
227 *> only calculates the optimal size of the WORK array, returns
228 *> this value as the first entry of the WORK array, and no error
229 *> message related to LWORK is issued by XERBLA.
230 *> \endverbatim
231 *>
232 *> \param[out] RWORK
233 *> \verbatim
234 *> RWORK is DOUBLE PRECISION array, dimension (7*N)
235 *> \endverbatim
236 *>
237 *> \param[out] IWORK
238 *> \verbatim
239 *> IWORK is INTEGER array, dimension (5*N)
240 *> \endverbatim
241 *>
242 *> \param[out] IFAIL
243 *> \verbatim
244 *> IFAIL is INTEGER array, dimension (N)
245 *> If JOBZ = 'V', then if INFO = 0, the first M elements of
246 *> IFAIL are zero. If INFO > 0, then IFAIL contains the
247 *> indices of the eigenvectors that failed to converge.
248 *> If JOBZ = 'N', then IFAIL is not referenced.
249 *> \endverbatim
250 *>
251 *> \param[out] INFO
252 *> \verbatim
253 *> INFO is INTEGER
254 *> = 0: successful exit
255 *> < 0: if INFO = -i, the i-th argument had an illegal value
256 *> > 0: if INFO = i, then i eigenvectors failed to converge.
257 *> Their indices are stored in array IFAIL.
258 *> \endverbatim
259 *
260 * Authors:
261 * ========
262 *
263 *> \author Univ. of Tennessee
264 *> \author Univ. of California Berkeley
265 *> \author Univ. of Colorado Denver
266 *> \author NAG Ltd.
267 *
268 *> \ingroup complex16HEeigen
269 *
270 *> \par Further Details:
271 * =====================
272 *>
273 *> \verbatim
274 *>
275 *> All details about the 2stage techniques are available in:
276 *>
277 *> Azzam Haidar, Hatem Ltaief, and Jack Dongarra.
278 *> Parallel reduction to condensed forms for symmetric eigenvalue problems
279 *> using aggregated fine-grained and memory-aware kernels. In Proceedings
280 *> of 2011 International Conference for High Performance Computing,
281 *> Networking, Storage and Analysis (SC '11), New York, NY, USA,
282 *> Article 8 , 11 pages.
283 *> http://doi.acm.org/10.1145/2063384.2063394
284 *>
285 *> A. Haidar, J. Kurzak, P. Luszczek, 2013.
286 *> An improved parallel singular value algorithm and its implementation
287 *> for multicore hardware, In Proceedings of 2013 International Conference
288 *> for High Performance Computing, Networking, Storage and Analysis (SC '13).
289 *> Denver, Colorado, USA, 2013.
290 *> Article 90, 12 pages.
291 *> http://doi.acm.org/10.1145/2503210.2503292
292 *>
293 *> A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra.
294 *> A novel hybrid CPU-GPU generalized eigensolver for electronic structure
295 *> calculations based on fine-grained memory aware tasks.
296 *> International Journal of High Performance Computing Applications.
297 *> Volume 28 Issue 2, Pages 196-209, May 2014.
298 *> http://hpc.sagepub.com/content/28/2/196
299 *>
300 *> \endverbatim
301 *
302 * =====================================================================
303  SUBROUTINE zheevx_2stage( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU,
304  \$ IL, IU, ABSTOL, M, W, Z, LDZ, WORK,
305  \$ LWORK, RWORK, IWORK, IFAIL, INFO )
306 *
307  IMPLICIT NONE
308 *
309 * -- LAPACK driver routine --
310 * -- LAPACK is a software package provided by Univ. of Tennessee, --
311 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
312 *
313 * .. Scalar Arguments ..
314  CHARACTER JOBZ, RANGE, UPLO
315  INTEGER IL, INFO, IU, LDA, LDZ, LWORK, M, N
316  DOUBLE PRECISION ABSTOL, VL, VU
317 * ..
318 * .. Array Arguments ..
319  INTEGER IFAIL( * ), IWORK( * )
320  DOUBLE PRECISION RWORK( * ), W( * )
321  COMPLEX*16 A( LDA, * ), WORK( * ), Z( LDZ, * )
322 * ..
323 *
324 * =====================================================================
325 *
326 * .. Parameters ..
327  DOUBLE PRECISION ZERO, ONE
328  PARAMETER ( ZERO = 0.0d+0, one = 1.0d+0 )
329  COMPLEX*16 CONE
330  parameter( cone = ( 1.0d+0, 0.0d+0 ) )
331 * ..
332 * .. Local Scalars ..
333  LOGICAL ALLEIG, INDEIG, LOWER, LQUERY, TEST, VALEIG,
334  \$ WANTZ
335  CHARACTER ORDER
336  INTEGER I, IINFO, IMAX, INDD, INDE, INDEE, INDIBL,
337  \$ indisp, indiwk, indrwk, indtau, indwrk, iscale,
338  \$ itmp1, j, jj, llwork,
339  \$ nsplit, lwmin, lhtrd, lwtrd, kd, ib, indhous
340  DOUBLE PRECISION ABSTLL, ANRM, BIGNUM, EPS, RMAX, RMIN, SAFMIN,
341  \$ SIGMA, SMLNUM, TMP1, VLL, VUU
342 * ..
343 * .. External Functions ..
344  LOGICAL LSAME
345  INTEGER ILAENV2STAGE
346  DOUBLE PRECISION DLAMCH, ZLANHE
347  EXTERNAL lsame, dlamch, zlanhe, ilaenv2stage
348 * ..
349 * .. External Subroutines ..
350  EXTERNAL dcopy, dscal, dstebz, dsterf, xerbla, zdscal,
352  \$ zhetrd_2stage
353 * ..
354 * .. Intrinsic Functions ..
355  INTRINSIC dble, max, min, sqrt
356 * ..
357 * .. Executable Statements ..
358 *
359 * Test the input parameters.
360 *
361  lower = lsame( uplo, 'L' )
362  wantz = lsame( jobz, 'V' )
363  alleig = lsame( range, 'A' )
364  valeig = lsame( range, 'V' )
365  indeig = lsame( range, 'I' )
366  lquery = ( lwork.EQ.-1 )
367 *
368  info = 0
369  IF( .NOT.( lsame( jobz, 'N' ) ) ) THEN
370  info = -1
371  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
372  info = -2
373  ELSE IF( .NOT.( lower .OR. lsame( uplo, 'U' ) ) ) THEN
374  info = -3
375  ELSE IF( n.LT.0 ) THEN
376  info = -4
377  ELSE IF( lda.LT.max( 1, n ) ) THEN
378  info = -6
379  ELSE
380  IF( valeig ) THEN
381  IF( n.GT.0 .AND. vu.LE.vl )
382  \$ info = -8
383  ELSE IF( indeig ) THEN
384  IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
385  info = -9
386  ELSE IF( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
387  info = -10
388  END IF
389  END IF
390  END IF
391  IF( info.EQ.0 ) THEN
392  IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
393  info = -15
394  END IF
395  END IF
396 *
397  IF( info.EQ.0 ) THEN
398  IF( n.LE.1 ) THEN
399  lwmin = 1
400  work( 1 ) = lwmin
401  ELSE
402  kd = ilaenv2stage( 1, 'ZHETRD_2STAGE', jobz,
403  \$ n, -1, -1, -1 )
404  ib = ilaenv2stage( 2, 'ZHETRD_2STAGE', jobz,
405  \$ n, kd, -1, -1 )
406  lhtrd = ilaenv2stage( 3, 'ZHETRD_2STAGE', jobz,
407  \$ n, kd, ib, -1 )
408  lwtrd = ilaenv2stage( 4, 'ZHETRD_2STAGE', jobz,
409  \$ n, kd, ib, -1 )
410  lwmin = n + lhtrd + lwtrd
411  work( 1 ) = lwmin
412  END IF
413 *
414  IF( lwork.LT.lwmin .AND. .NOT.lquery )
415  \$ info = -17
416  END IF
417 *
418  IF( info.NE.0 ) THEN
419  CALL xerbla( 'ZHEEVX_2STAGE', -info )
420  RETURN
421  ELSE IF( lquery ) THEN
422  RETURN
423  END IF
424 *
425 * Quick return if possible
426 *
427  m = 0
428  IF( n.EQ.0 ) THEN
429  RETURN
430  END IF
431 *
432  IF( n.EQ.1 ) THEN
433  IF( alleig .OR. indeig ) THEN
434  m = 1
435  w( 1 ) = dble( a( 1, 1 ) )
436  ELSE IF( valeig ) THEN
437  IF( vl.LT.dble( a( 1, 1 ) ) .AND. vu.GE.dble( a( 1, 1 ) ) )
438  \$ THEN
439  m = 1
440  w( 1 ) = dble( a( 1, 1 ) )
441  END IF
442  END IF
443  IF( wantz )
444  \$ z( 1, 1 ) = cone
445  RETURN
446  END IF
447 *
448 * Get machine constants.
449 *
450  safmin = dlamch( 'Safe minimum' )
451  eps = dlamch( 'Precision' )
452  smlnum = safmin / eps
453  bignum = one / smlnum
454  rmin = sqrt( smlnum )
455  rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
456 *
457 * Scale matrix to allowable range, if necessary.
458 *
459  iscale = 0
460  abstll = abstol
461  IF( valeig ) THEN
462  vll = vl
463  vuu = vu
464  END IF
465  anrm = zlanhe( 'M', uplo, n, a, lda, rwork )
466  IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
467  iscale = 1
468  sigma = rmin / anrm
469  ELSE IF( anrm.GT.rmax ) THEN
470  iscale = 1
471  sigma = rmax / anrm
472  END IF
473  IF( iscale.EQ.1 ) THEN
474  IF( lower ) THEN
475  DO 10 j = 1, n
476  CALL zdscal( n-j+1, sigma, a( j, j ), 1 )
477  10 CONTINUE
478  ELSE
479  DO 20 j = 1, n
480  CALL zdscal( j, sigma, a( 1, j ), 1 )
481  20 CONTINUE
482  END IF
483  IF( abstol.GT.0 )
484  \$ abstll = abstol*sigma
485  IF( valeig ) THEN
486  vll = vl*sigma
487  vuu = vu*sigma
488  END IF
489  END IF
490 *
491 * Call ZHETRD_2STAGE to reduce Hermitian matrix to tridiagonal form.
492 *
493  indd = 1
494  inde = indd + n
495  indrwk = inde + n
496  indtau = 1
497  indhous = indtau + n
498  indwrk = indhous + lhtrd
499  llwork = lwork - indwrk + 1
500 *
501  CALL zhetrd_2stage( jobz, uplo, n, a, lda, rwork( indd ),
502  \$ rwork( inde ), work( indtau ),
503  \$ work( indhous ), lhtrd, work( indwrk ),
504  \$ llwork, iinfo )
505 *
506 * If all eigenvalues are desired and ABSTOL is less than or equal to
507 * zero, then call DSTERF or ZUNGTR and ZSTEQR. If this fails for
508 * some eigenvalue, then try DSTEBZ.
509 *
510  test = .false.
511  IF( indeig ) THEN
512  IF( il.EQ.1 .AND. iu.EQ.n ) THEN
513  test = .true.
514  END IF
515  END IF
516  IF( ( alleig .OR. test ) .AND. ( abstol.LE.zero ) ) THEN
517  CALL dcopy( n, rwork( indd ), 1, w, 1 )
518  indee = indrwk + 2*n
519  IF( .NOT.wantz ) THEN
520  CALL dcopy( n-1, rwork( inde ), 1, rwork( indee ), 1 )
521  CALL dsterf( n, w, rwork( indee ), info )
522  ELSE
523  CALL zlacpy( 'A', n, n, a, lda, z, ldz )
524  CALL zungtr( uplo, n, z, ldz, work( indtau ),
525  \$ work( indwrk ), llwork, iinfo )
526  CALL dcopy( n-1, rwork( inde ), 1, rwork( indee ), 1 )
527  CALL zsteqr( jobz, n, w, rwork( indee ), z, ldz,
528  \$ rwork( indrwk ), info )
529  IF( info.EQ.0 ) THEN
530  DO 30 i = 1, n
531  ifail( i ) = 0
532  30 CONTINUE
533  END IF
534  END IF
535  IF( info.EQ.0 ) THEN
536  m = n
537  GO TO 40
538  END IF
539  info = 0
540  END IF
541 *
542 * Otherwise, call DSTEBZ and, if eigenvectors are desired, ZSTEIN.
543 *
544  IF( wantz ) THEN
545  order = 'B'
546  ELSE
547  order = 'E'
548  END IF
549  indibl = 1
550  indisp = indibl + n
551  indiwk = indisp + n
552  CALL dstebz( range, order, n, vll, vuu, il, iu, abstll,
553  \$ rwork( indd ), rwork( inde ), m, nsplit, w,
554  \$ iwork( indibl ), iwork( indisp ), rwork( indrwk ),
555  \$ iwork( indiwk ), info )
556 *
557  IF( wantz ) THEN
558  CALL zstein( n, rwork( indd ), rwork( inde ), m, w,
559  \$ iwork( indibl ), iwork( indisp ), z, ldz,
560  \$ rwork( indrwk ), iwork( indiwk ), ifail, info )
561 *
562 * Apply unitary matrix used in reduction to tridiagonal
563 * form to eigenvectors returned by ZSTEIN.
564 *
565  CALL zunmtr( 'L', uplo, 'N', n, m, a, lda, work( indtau ), z,
566  \$ ldz, work( indwrk ), llwork, iinfo )
567  END IF
568 *
569 * If matrix was scaled, then rescale eigenvalues appropriately.
570 *
571  40 CONTINUE
572  IF( iscale.EQ.1 ) THEN
573  IF( info.EQ.0 ) THEN
574  imax = m
575  ELSE
576  imax = info - 1
577  END IF
578  CALL dscal( imax, one / sigma, w, 1 )
579  END IF
580 *
581 * If eigenvalues are not in order, then sort them, along with
582 * eigenvectors.
583 *
584  IF( wantz ) THEN
585  DO 60 j = 1, m - 1
586  i = 0
587  tmp1 = w( j )
588  DO 50 jj = j + 1, m
589  IF( w( jj ).LT.tmp1 ) THEN
590  i = jj
591  tmp1 = w( jj )
592  END IF
593  50 CONTINUE
594 *
595  IF( i.NE.0 ) THEN
596  itmp1 = iwork( indibl+i-1 )
597  w( i ) = w( j )
598  iwork( indibl+i-1 ) = iwork( indibl+j-1 )
599  w( j ) = tmp1
600  iwork( indibl+j-1 ) = itmp1
601  CALL zswap( n, z( 1, i ), 1, z( 1, j ), 1 )
602  IF( info.NE.0 ) THEN
603  itmp1 = ifail( i )
604  ifail( i ) = ifail( j )
605  ifail( j ) = itmp1
606  END IF
607  END IF
608  60 CONTINUE
609  END IF
610 *
611 * Set WORK(1) to optimal complex workspace size.
612 *
613  work( 1 ) = lwmin
614 *
615  RETURN
616 *
617 * End of ZHEEVX_2STAGE
618 *
619  END
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine dstebz(RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, INFO)
DSTEBZ
Definition: dstebz.f:273
subroutine dsterf(N, D, E, INFO)
DSTERF
Definition: dsterf.f:86
subroutine zswap(N, ZX, INCX, ZY, INCY)
ZSWAP
Definition: zswap.f:81
subroutine zdscal(N, DA, ZX, INCX)
ZDSCAL
Definition: zdscal.f:78
subroutine zhetrd_2stage(VECT, UPLO, N, A, LDA, D, E, TAU, HOUS2, LHOUS2, WORK, LWORK, INFO)
ZHETRD_2STAGE
subroutine zheevx_2stage(JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK, IFAIL, INFO)
ZHEEVX_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE mat...
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:103
subroutine zsteqr(COMPZ, N, D, E, Z, LDZ, WORK, INFO)
ZSTEQR
Definition: zsteqr.f:132
subroutine zunmtr(SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
ZUNMTR
Definition: zunmtr.f:171
subroutine zungtr(UPLO, N, A, LDA, TAU, WORK, LWORK, INFO)
ZUNGTR
Definition: zungtr.f:123
subroutine zstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
ZSTEIN
Definition: zstein.f:182
subroutine dcopy(N, DX, INCX, DY, INCY)
DCOPY
Definition: dcopy.f:82
subroutine dscal(N, DA, DX, INCX)
DSCAL
Definition: dscal.f:79