LAPACK 3.12.1
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ cheevd()

subroutine cheevd ( character jobz,
character uplo,
integer n,
complex, dimension( lda, * ) a,
integer lda,
real, dimension( * ) w,
complex, dimension( * ) work,
integer lwork,
real, dimension( * ) rwork,
integer lrwork,
integer, dimension( * ) iwork,
integer liwork,
integer info )

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

Download CHEEVD + dependencies [TGZ] [ZIP] [TXT]

Purpose:
!>
!> CHEEVD computes all eigenvalues and, optionally, eigenvectors of a
!> complex Hermitian matrix A.  If eigenvectors are desired, it uses a
!> divide and conquer algorithm.
!>
!>
Parameters
[in]JOBZ
!>          JOBZ is CHARACTER*1
!>          = 'N':  Compute eigenvalues only;
!>          = 'V':  Compute eigenvalues and eigenvectors.
!>
[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.
!>          If N <= 1,                LWORK must be at least 1.
!>          If JOBZ  = 'N' and N > 1, LWORK must be at least N + 1.
!>          If JOBZ  = 'V' and N > 1, LWORK must be at least 2*N + N**2.
!>
!>          If LWORK = -1, then a workspace query is assumed; the routine
!>          only calculates the optimal sizes of the WORK, RWORK and
!>          IWORK arrays, returns these values as the first entries of
!>          the WORK, RWORK and IWORK arrays, and no error message
!>          related to LWORK or LRWORK or LIWORK is issued by XERBLA.
!>
[out]RWORK
!>          RWORK is REAL array, dimension (MAX(1,LRWORK))
!>          On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
!>
[in]LRWORK
!>          LRWORK is INTEGER
!>          The dimension of the array RWORK.
!>          If N <= 1,                LRWORK must be at least 1.
!>          If JOBZ  = 'N' and N > 1, LRWORK must be at least N.
!>          If JOBZ  = 'V' and N > 1, LRWORK must be at least
!>                         1 + 5*N + 2*N**2.
!>
!>          If LRWORK = -1, then a workspace query is assumed; the
!>          routine only calculates the optimal sizes of the WORK, RWORK
!>          and IWORK arrays, returns these values as the first entries
!>          of the WORK, RWORK and IWORK arrays, and no error message
!>          related to LWORK or LRWORK or LIWORK is issued by XERBLA.
!>
[out]IWORK
!>          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
!>          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
!>
[in]LIWORK
!>          LIWORK is INTEGER
!>          The dimension of the array IWORK.
!>          If N <= 1,                LIWORK must be at least 1.
!>          If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.
!>          If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.
!>
!>          If LIWORK = -1, then a workspace query is assumed; the
!>          routine only calculates the optimal sizes of the WORK, RWORK
!>          and IWORK arrays, returns these values as the first entries
!>          of the WORK, RWORK and IWORK arrays, and no error message
!>          related to LWORK or LRWORK or LIWORK is issued by XERBLA.
!>
[out]INFO
!>          INFO is INTEGER
!>          = 0:  successful exit
!>          < 0:  if INFO = -i, the i-th argument had an illegal value
!>          > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed
!>                to converge; i off-diagonal elements of an intermediate
!>                tridiagonal form did not converge to zero;
!>                if INFO = i and JOBZ = 'V', then the algorithm failed
!>                to compute an eigenvalue while working on the submatrix
!>                lying in rows and columns INFO/(N+1) through
!>                mod(INFO,N+1).
!>
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Further Details:
Modified description of INFO. Sven, 16 Feb 05.
Contributors:
Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Definition at line 194 of file cheevd.f.

197*
198* -- LAPACK driver routine --
199* -- LAPACK is a software package provided by Univ. of Tennessee, --
200* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
201*
202* .. Scalar Arguments ..
203 CHARACTER JOBZ, UPLO
204 INTEGER INFO, LDA, LIWORK, LRWORK, LWORK, N
205* ..
206* .. Array Arguments ..
207 INTEGER IWORK( * )
208 REAL RWORK( * ), W( * )
209 COMPLEX A( LDA, * ), WORK( * )
210* ..
211*
212* =====================================================================
213*
214* .. Parameters ..
215 REAL ZERO, ONE
216 parameter( zero = 0.0e0, one = 1.0e0 )
217 COMPLEX CONE
218 parameter( cone = ( 1.0e0, 0.0e0 ) )
219* ..
220* .. Local Scalars ..
221 LOGICAL LOWER, LQUERY, WANTZ
222 INTEGER IINFO, IMAX, INDE, INDRWK, INDTAU, INDWK2,
223 $ INDWRK, ISCALE, LIOPT, LIWMIN, LLRWK, LLWORK,
224 $ LLWRK2, LOPT, LROPT, LRWMIN, LWMIN
225 REAL ANRM, BIGNUM, EPS, RMAX, RMIN, SAFMIN, SIGMA,
226 $ SMLNUM
227* ..
228* .. External Functions ..
229 LOGICAL LSAME
230 INTEGER ILAENV
231 REAL CLANHE, SLAMCH, SROUNDUP_LWORK
232 EXTERNAL ilaenv, lsame, clanhe, slamch,
233 $ sroundup_lwork
234* ..
235* .. External Subroutines ..
236 EXTERNAL chetrd, clacpy, clascl, cstedc, cunmtr,
237 $ sscal,
238 $ ssterf, xerbla
239* ..
240* .. Intrinsic Functions ..
241 INTRINSIC max, sqrt
242* ..
243* .. Executable Statements ..
244*
245* Test the input parameters.
246*
247 wantz = lsame( jobz, 'V' )
248 lower = lsame( uplo, 'L' )
249 lquery = ( lwork.EQ.-1 .OR. lrwork.EQ.-1 .OR. liwork.EQ.-1 )
250*
251 info = 0
252 IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
253 info = -1
254 ELSE IF( .NOT.( lower .OR. lsame( uplo, 'U' ) ) ) THEN
255 info = -2
256 ELSE IF( n.LT.0 ) THEN
257 info = -3
258 ELSE IF( lda.LT.max( 1, n ) ) THEN
259 info = -5
260 END IF
261*
262 IF( info.EQ.0 ) THEN
263 IF( n.LE.1 ) THEN
264 lwmin = 1
265 lrwmin = 1
266 liwmin = 1
267 lopt = lwmin
268 lropt = lrwmin
269 liopt = liwmin
270 ELSE
271 IF( wantz ) THEN
272 lwmin = 2*n + n*n
273 lrwmin = 1 + 5*n + 2*n**2
274 liwmin = 3 + 5*n
275 ELSE
276 lwmin = n + 1
277 lrwmin = n
278 liwmin = 1
279 END IF
280 lopt = max( lwmin, n +
281 $ n*ilaenv( 1, 'CHETRD', uplo, n, -1, -1,
282 $ -1 ) )
283 lropt = lrwmin
284 liopt = liwmin
285 END IF
286 work( 1 ) = sroundup_lwork( lopt )
287 rwork( 1 ) = sroundup_lwork( lropt )
288 iwork( 1 ) = liopt
289*
290 IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
291 info = -8
292 ELSE IF( lrwork.LT.lrwmin .AND. .NOT.lquery ) THEN
293 info = -10
294 ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
295 info = -12
296 END IF
297 END IF
298*
299 IF( info.NE.0 ) THEN
300 CALL xerbla( 'CHEEVD', -info )
301 RETURN
302 ELSE IF( lquery ) THEN
303 RETURN
304 END IF
305*
306* Quick return if possible
307*
308 IF( n.EQ.0 )
309 $ RETURN
310*
311 IF( n.EQ.1 ) THEN
312 w( 1 ) = real( a( 1, 1 ) )
313 IF( wantz )
314 $ a( 1, 1 ) = cone
315 RETURN
316 END IF
317*
318* Get machine constants.
319*
320 safmin = slamch( 'Safe minimum' )
321 eps = slamch( 'Precision' )
322 smlnum = safmin / eps
323 bignum = one / smlnum
324 rmin = sqrt( smlnum )
325 rmax = sqrt( bignum )
326*
327* Scale matrix to allowable range, if necessary.
328*
329 anrm = clanhe( 'M', uplo, n, a, lda, rwork )
330 iscale = 0
331 IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
332 iscale = 1
333 sigma = rmin / anrm
334 ELSE IF( anrm.GT.rmax ) THEN
335 iscale = 1
336 sigma = rmax / anrm
337 END IF
338 IF( iscale.EQ.1 )
339 $ CALL clascl( uplo, 0, 0, one, sigma, n, n, a, lda, info )
340*
341* Call CHETRD to reduce Hermitian matrix to tridiagonal form.
342*
343 inde = 1
344 indtau = 1
345 indwrk = indtau + n
346 indrwk = inde + n
347 indwk2 = indwrk + n*n
348 llwork = lwork - indwrk + 1
349 llwrk2 = lwork - indwk2 + 1
350 llrwk = lrwork - indrwk + 1
351 CALL chetrd( uplo, n, a, lda, w, rwork( inde ), work( indtau ),
352 $ work( indwrk ), llwork, iinfo )
353*
354* For eigenvalues only, call SSTERF. For eigenvectors, first call
355* CSTEDC to generate the eigenvector matrix, WORK(INDWRK), of the
356* tridiagonal matrix, then call CUNMTR to multiply it to the
357* Householder transformations represented as Householder vectors in
358* A.
359*
360 IF( .NOT.wantz ) THEN
361 CALL ssterf( n, w, rwork( inde ), info )
362 ELSE
363 CALL cstedc( 'I', n, w, rwork( inde ), work( indwrk ), n,
364 $ work( indwk2 ), llwrk2, rwork( indrwk ), llrwk,
365 $ iwork, liwork, info )
366 CALL cunmtr( 'L', uplo, 'N', n, n, a, lda, work( indtau ),
367 $ work( indwrk ), n, work( indwk2 ), llwrk2, iinfo )
368 CALL clacpy( 'A', n, n, work( indwrk ), n, a, lda )
369 END IF
370*
371* If matrix was scaled, then rescale eigenvalues appropriately.
372*
373 IF( iscale.EQ.1 ) THEN
374 IF( info.EQ.0 ) THEN
375 imax = n
376 ELSE
377 imax = info - 1
378 END IF
379 CALL sscal( imax, one / sigma, w, 1 )
380 END IF
381*
382 work( 1 ) = sroundup_lwork( lopt )
383 rwork( 1 ) = sroundup_lwork( lropt )
384 iwork( 1 ) = liopt
385*
386 RETURN
387*
388* End of CHEEVD
389*
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
chetrd
subroutine chetrd(uplo, n, a, lda, d, e, tau, work, lwork, info)
CHETRD
Definition chetrd.f:191
ilaenv
integer function ilaenv(ispec, name, opts, n1, n2, n3, n4)
ILAENV
Definition ilaenv.f:160
clacpy
subroutine clacpy(uplo, m, n, a, lda, b, ldb)
CLACPY copies all or part of one two-dimensional array to another.
Definition clacpy.f:101
slamch
real function slamch(cmach)
SLAMCH
Definition slamch.f:68
clanhe
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:122
clascl
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:142
lsame
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
sroundup_lwork
real function sroundup_lwork(lwork)
SROUNDUP_LWORK
Definition sroundup_lwork.f:59
sscal
subroutine sscal(n, sa, sx, incx)
SSCAL
Definition sscal.f:79
cstedc
subroutine cstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
CSTEDC
Definition cstedc.f:204
ssterf
subroutine ssterf(n, d, e, info)
SSTERF
Definition ssterf.f:84
cunmtr
subroutine cunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info)
CUNMTR
Definition cunmtr.f:171
Here is the call graph for this function:
Here is the caller graph for this function: