 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ cheev_2stage()

 subroutine cheev_2stage ( character JOBZ, character UPLO, integer N, complex, dimension( lda, * ) A, integer LDA, real, dimension( * ) W, complex, dimension( * ) WORK, integer LWORK, real, dimension( * ) RWORK, integer INFO )

CHEEV_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for HE matrices

Purpose:
``` CHEEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a
complex Hermitian matrix A using the 2stage technique for
the reduction to tridiagonal.```
Parameters
 [in] JOBZ ``` JOBZ is CHARACTER*1 = 'N': Compute eigenvalues only; = 'V': Compute eigenvalues and eigenvectors. Not available in this release.``` [in] UPLO ``` UPLO is CHARACTER*1 = 'U': Upper triangle of A is stored; = 'L': Lower triangle of A is stored.``` [in] N ``` N is INTEGER The order of the matrix A. N >= 0.``` [in,out] A ``` A is COMPLEX array, dimension (LDA, N) On entry, the Hermitian matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A. On exit, if JOBZ = 'V', then if INFO = 0, A contains the orthonormal eigenvectors of the matrix A. If JOBZ = 'N', then on exit the lower triangle (if UPLO='L') or the upper triangle (if UPLO='U') of A, including the diagonal, is destroyed.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).``` [out] W ``` W is REAL array, dimension (N) If INFO = 0, the eigenvalues in ascending order.``` [out] WORK ``` WORK is COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The length of the array WORK. LWORK >= 1, when N <= 1; otherwise If JOBZ = 'N' and N > 1, LWORK must be queried. LWORK = MAX(1, dimension) where dimension = max(stage1,stage2) + (KD+1)*N + N = N*KD + N*max(KD+1,FACTOPTNB) + max(2*KD*KD, KD*NTHREADS) + (KD+1)*N + N where KD is the blocking size of the reduction, FACTOPTNB is the blocking used by the QR or LQ algorithm, usually FACTOPTNB=128 is a good choice NTHREADS is the number of threads used when openMP compilation is enabled, otherwise =1. If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.``` [out] RWORK ` RWORK is REAL array, dimension (max(1, 3*N-2))` [out] INFO ``` INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.```
Further Details:
```  All details about the 2stage techniques are available in:

Azzam Haidar, Hatem Ltaief, and Jack Dongarra.
Parallel reduction to condensed forms for symmetric eigenvalue problems
using aggregated fine-grained and memory-aware kernels. In Proceedings
of 2011 International Conference for High Performance Computing,
Networking, Storage and Analysis (SC '11), New York, NY, USA,
Article 8 , 11 pages.
http://doi.acm.org/10.1145/2063384.2063394

A. Haidar, J. Kurzak, P. Luszczek, 2013.
An improved parallel singular value algorithm and its implementation
for multicore hardware, In Proceedings of 2013 International Conference
for High Performance Computing, Networking, Storage and Analysis (SC '13).
Article 90, 12 pages.
http://doi.acm.org/10.1145/2503210.2503292

A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra.
A novel hybrid CPU-GPU generalized eigensolver for electronic structure
calculations based on fine-grained memory aware tasks.
International Journal of High Performance Computing Applications.
Volume 28 Issue 2, Pages 196-209, May 2014.
http://hpc.sagepub.com/content/28/2/196 ```

Definition at line 187 of file cheev_2stage.f.

189 *
190  IMPLICIT NONE
191 *
192 * -- LAPACK driver routine --
193 * -- LAPACK is a software package provided by Univ. of Tennessee, --
194 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
195 *
196 * .. Scalar Arguments ..
197  CHARACTER JOBZ, UPLO
198  INTEGER INFO, LDA, LWORK, N
199 * ..
200 * .. Array Arguments ..
201  REAL RWORK( * ), W( * )
202  COMPLEX A( LDA, * ), WORK( * )
203 * ..
204 *
205 * =====================================================================
206 *
207 * .. Parameters ..
208  REAL ZERO, ONE
209  parameter( zero = 0.0e0, one = 1.0e0 )
210  COMPLEX CONE
211  parameter( cone = ( 1.0e0, 0.0e0 ) )
212 * ..
213 * .. Local Scalars ..
214  LOGICAL LOWER, LQUERY, WANTZ
215  INTEGER IINFO, IMAX, INDE, INDTAU, INDWRK, ISCALE,
216  \$ LLWORK, LWMIN, LHTRD, LWTRD, KD, IB, INDHOUS
217  REAL ANRM, BIGNUM, EPS, RMAX, RMIN, SAFMIN, SIGMA,
218  \$ SMLNUM
219 * ..
220 * .. External Functions ..
221  LOGICAL LSAME
222  INTEGER ILAENV2STAGE
223  REAL SLAMCH, CLANHE
224  EXTERNAL lsame, slamch, clanhe, ilaenv2stage
225 * ..
226 * .. External Subroutines ..
227  EXTERNAL sscal, ssterf, xerbla, clascl, csteqr,
229 * ..
230 * .. Intrinsic Functions ..
231  INTRINSIC real, max, sqrt
232 * ..
233 * .. Executable Statements ..
234 *
235 * Test the input parameters.
236 *
237  wantz = lsame( jobz, 'V' )
238  lower = lsame( uplo, 'L' )
239  lquery = ( lwork.EQ.-1 )
240 *
241  info = 0
242  IF( .NOT.( lsame( jobz, 'N' ) ) ) THEN
243  info = -1
244  ELSE IF( .NOT.( lower .OR. lsame( uplo, 'U' ) ) ) THEN
245  info = -2
246  ELSE IF( n.LT.0 ) THEN
247  info = -3
248  ELSE IF( lda.LT.max( 1, n ) ) THEN
249  info = -5
250  END IF
251 *
252  IF( info.EQ.0 ) THEN
253  kd = ilaenv2stage( 1, 'CHETRD_2STAGE', jobz, n, -1, -1, -1 )
254  ib = ilaenv2stage( 2, 'CHETRD_2STAGE', jobz, n, kd, -1, -1 )
255  lhtrd = ilaenv2stage( 3, 'CHETRD_2STAGE', jobz, n, kd, ib, -1 )
256  lwtrd = ilaenv2stage( 4, 'CHETRD_2STAGE', jobz, n, kd, ib, -1 )
257  lwmin = n + lhtrd + lwtrd
258  work( 1 ) = lwmin
259 *
260  IF( lwork.LT.lwmin .AND. .NOT.lquery )
261  \$ info = -8
262  END IF
263 *
264  IF( info.NE.0 ) THEN
265  CALL xerbla( 'CHEEV_2STAGE ', -info )
266  RETURN
267  ELSE IF( lquery ) THEN
268  RETURN
269  END IF
270 *
271 * Quick return if possible
272 *
273  IF( n.EQ.0 ) THEN
274  RETURN
275  END IF
276 *
277  IF( n.EQ.1 ) THEN
278  w( 1 ) = real( a( 1, 1 ) )
279  work( 1 ) = 1
280  IF( wantz )
281  \$ a( 1, 1 ) = cone
282  RETURN
283  END IF
284 *
285 * Get machine constants.
286 *
287  safmin = slamch( 'Safe minimum' )
288  eps = slamch( 'Precision' )
289  smlnum = safmin / eps
290  bignum = one / smlnum
291  rmin = sqrt( smlnum )
292  rmax = sqrt( bignum )
293 *
294 * Scale matrix to allowable range, if necessary.
295 *
296  anrm = clanhe( 'M', uplo, n, a, lda, rwork )
297  iscale = 0
298  IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
299  iscale = 1
300  sigma = rmin / anrm
301  ELSE IF( anrm.GT.rmax ) THEN
302  iscale = 1
303  sigma = rmax / anrm
304  END IF
305  IF( iscale.EQ.1 )
306  \$ CALL clascl( uplo, 0, 0, one, sigma, n, n, a, lda, info )
307 *
308 * Call CHETRD_2STAGE to reduce Hermitian matrix to tridiagonal form.
309 *
310  inde = 1
311  indtau = 1
312  indhous = indtau + n
313  indwrk = indhous + lhtrd
314  llwork = lwork - indwrk + 1
315 *
316  CALL chetrd_2stage( jobz, uplo, n, a, lda, w, rwork( inde ),
317  \$ work( indtau ), work( indhous ), lhtrd,
318  \$ work( indwrk ), llwork, iinfo )
319 *
320 * For eigenvalues only, call SSTERF. For eigenvectors, first call
321 * CUNGTR to generate the unitary matrix, then call CSTEQR.
322 *
323  IF( .NOT.wantz ) THEN
324  CALL ssterf( n, w, rwork( inde ), info )
325  ELSE
326  CALL cungtr( uplo, n, a, lda, work( indtau ), work( indwrk ),
327  \$ llwork, iinfo )
328  indwrk = inde + n
329  CALL csteqr( jobz, n, w, rwork( inde ), a, lda,
330  \$ rwork( indwrk ), info )
331  END IF
332 *
333 * If matrix was scaled, then rescale eigenvalues appropriately.
334 *
335  IF( iscale.EQ.1 ) THEN
336  IF( info.EQ.0 ) THEN
337  imax = n
338  ELSE
339  imax = info - 1
340  END IF
341  CALL sscal( imax, one / sigma, w, 1 )
342  END IF
343 *
344 * Set WORK(1) to optimal complex workspace size.
345 *
346  work( 1 ) = lwmin
347 *
348  RETURN
349 *
350 * End of CHEEV_2STAGE
351 *
integer function ilaenv2stage(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV2STAGE
Definition: ilaenv2stage.f:149
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:86
real function clanhe(NORM, UPLO, N, A, LDA, WORK)
CLANHE returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: clanhe.f:124
subroutine chetrd_2stage(VECT, UPLO, N, A, LDA, D, E, TAU, HOUS2, LHOUS2, WORK, LWORK, INFO)
CHETRD_2STAGE
subroutine clascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
CLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: clascl.f:143
subroutine csteqr(COMPZ, N, D, E, Z, LDZ, WORK, INFO)
CSTEQR
Definition: csteqr.f:132
subroutine cungtr(UPLO, N, A, LDA, TAU, WORK, LWORK, INFO)
CUNGTR
Definition: cungtr.f:123
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:79
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
Here is the call graph for this function:
Here is the caller graph for this function: