LAPACK  3.10.0 LAPACK: Linear Algebra PACKage

## ◆ dsygvd()

 subroutine dsygvd ( integer ITYPE, character JOBZ, character UPLO, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) W, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, integer INFO )

DSYGVD

Purpose:
``` DSYGVD computes all the eigenvalues, and optionally, the eigenvectors
of a real generalized symmetric-definite eigenproblem, of the form
A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and
B are assumed to be symmetric and B is also positive definite.
If eigenvectors are desired, it uses a divide and conquer algorithm.

The divide and conquer algorithm makes very mild assumptions about
floating point arithmetic. It will work on machines with a guard
digit in add/subtract, or on those binary machines without guard
digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or
Cray-2. It could conceivably fail on hexadecimal or decimal machines
without guard digits, but we know of none.```
Parameters
 [in] ITYPE ``` ITYPE is INTEGER Specifies the problem type to be solved: = 1: A*x = (lambda)*B*x = 2: A*B*x = (lambda)*x = 3: B*A*x = (lambda)*x``` [in] JOBZ ``` JOBZ is CHARACTER*1 = 'N': Compute eigenvalues only; = 'V': Compute eigenvalues and eigenvectors.``` [in] UPLO ``` UPLO is CHARACTER*1 = 'U': Upper triangles of A and B are stored; = 'L': Lower triangles of A and B are stored.``` [in] N ``` N is INTEGER The order of the matrices A and B. N >= 0.``` [in,out] A ``` A is DOUBLE PRECISION array, dimension (LDA, N) On entry, the symmetric 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 matrix Z of eigenvectors. The eigenvectors are normalized as follows: if ITYPE = 1 or 2, Z**T*B*Z = I; if ITYPE = 3, Z**T*inv(B)*Z = I. If JOBZ = 'N', then on exit the upper triangle (if UPLO='U') or the lower triangle (if UPLO='L') of A, including the diagonal, is destroyed.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).``` [in,out] B ``` B is DOUBLE PRECISION array, dimension (LDB, N) On entry, the symmetric matrix B. If UPLO = 'U', the leading N-by-N upper triangular part of B contains the upper triangular part of the matrix B. If UPLO = 'L', the leading N-by-N lower triangular part of B contains the lower triangular part of the matrix B. On exit, if INFO <= N, the part of B containing the matrix is overwritten by the triangular factor U or L from the Cholesky factorization B = U**T*U or B = L*L**T.``` [in] LDB ``` LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).``` [out] W ``` W is DOUBLE PRECISION array, dimension (N) If INFO = 0, the eigenvalues in ascending order.``` [out] WORK ``` WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. If N <= 1, LWORK >= 1. If JOBZ = 'N' and N > 1, LWORK >= 2*N+1. If JOBZ = 'V' and N > 1, LWORK >= 1 + 6*N + 2*N**2. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK 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 >= 1. If JOBZ = 'N' and N > 1, LIWORK >= 1. If JOBZ = 'V' and N > 1, LIWORK >= 3 + 5*N. If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK and IWORK arrays, returns these values as the first entries of the WORK and IWORK arrays, and no error message related to LWORK 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: DPOTRF or DSYEVD returned an error code: <= N: 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); > N: if INFO = N + i, for 1 <= i <= N, then the leading minor of order i of B is not positive definite. The factorization of B could not be completed and no eigenvalues or eigenvectors were computed.```
Further Details:
```  Modified so that no backsubstitution is performed if DSYEVD fails to
converge (NEIG in old code could be greater than N causing out of
bounds reference to A - reported by Ralf Meyer).  Also corrected the
description of INFO and the test on ITYPE. Sven, 16 Feb 05.```
Contributors:
Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

Definition at line 225 of file dsygvd.f.

227 *
228 * -- LAPACK driver routine --
229 * -- LAPACK is a software package provided by Univ. of Tennessee, --
230 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
231 *
232 * .. Scalar Arguments ..
233  CHARACTER JOBZ, UPLO
234  INTEGER INFO, ITYPE, LDA, LDB, LIWORK, LWORK, N
235 * ..
236 * .. Array Arguments ..
237  INTEGER IWORK( * )
238  DOUBLE PRECISION A( LDA, * ), B( LDB, * ), W( * ), WORK( * )
239 * ..
240 *
241 * =====================================================================
242 *
243 * .. Parameters ..
244  DOUBLE PRECISION ONE
245  parameter( one = 1.0d+0 )
246 * ..
247 * .. Local Scalars ..
248  LOGICAL LQUERY, UPPER, WANTZ
249  CHARACTER TRANS
250  INTEGER LIOPT, LIWMIN, LOPT, LWMIN
251 * ..
252 * .. External Functions ..
253  LOGICAL LSAME
254  EXTERNAL lsame
255 * ..
256 * .. External Subroutines ..
257  EXTERNAL dpotrf, dsyevd, dsygst, dtrmm, dtrsm, xerbla
258 * ..
259 * .. Intrinsic Functions ..
260  INTRINSIC dble, max
261 * ..
262 * .. Executable Statements ..
263 *
264 * Test the input parameters.
265 *
266  wantz = lsame( jobz, 'V' )
267  upper = lsame( uplo, 'U' )
268  lquery = ( lwork.EQ.-1 .OR. liwork.EQ.-1 )
269 *
270  info = 0
271  IF( n.LE.1 ) THEN
272  liwmin = 1
273  lwmin = 1
274  ELSE IF( wantz ) THEN
275  liwmin = 3 + 5*n
276  lwmin = 1 + 6*n + 2*n**2
277  ELSE
278  liwmin = 1
279  lwmin = 2*n + 1
280  END IF
281  lopt = lwmin
282  liopt = liwmin
283  IF( itype.LT.1 .OR. itype.GT.3 ) THEN
284  info = -1
285  ELSE IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
286  info = -2
287  ELSE IF( .NOT.( upper .OR. lsame( uplo, 'L' ) ) ) THEN
288  info = -3
289  ELSE IF( n.LT.0 ) THEN
290  info = -4
291  ELSE IF( lda.LT.max( 1, n ) ) THEN
292  info = -6
293  ELSE IF( ldb.LT.max( 1, n ) ) THEN
294  info = -8
295  END IF
296 *
297  IF( info.EQ.0 ) THEN
298  work( 1 ) = lopt
299  iwork( 1 ) = liopt
300 *
301  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
302  info = -11
303  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
304  info = -13
305  END IF
306  END IF
307 *
308  IF( info.NE.0 ) THEN
309  CALL xerbla( 'DSYGVD', -info )
310  RETURN
311  ELSE IF( lquery ) THEN
312  RETURN
313  END IF
314 *
315 * Quick return if possible
316 *
317  IF( n.EQ.0 )
318  \$ RETURN
319 *
320 * Form a Cholesky factorization of B.
321 *
322  CALL dpotrf( uplo, n, b, ldb, info )
323  IF( info.NE.0 ) THEN
324  info = n + info
325  RETURN
326  END IF
327 *
328 * Transform problem to standard eigenvalue problem and solve.
329 *
330  CALL dsygst( itype, uplo, n, a, lda, b, ldb, info )
331  CALL dsyevd( jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork,
332  \$ info )
333  lopt = max( dble( lopt ), dble( work( 1 ) ) )
334  liopt = max( dble( liopt ), dble( iwork( 1 ) ) )
335 *
336  IF( wantz .AND. info.EQ.0 ) THEN
337 *
338 * Backtransform eigenvectors to the original problem.
339 *
340  IF( itype.EQ.1 .OR. itype.EQ.2 ) THEN
341 *
342 * For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
343 * backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
344 *
345  IF( upper ) THEN
346  trans = 'N'
347  ELSE
348  trans = 'T'
349  END IF
350 *
351  CALL dtrsm( 'Left', uplo, trans, 'Non-unit', n, n, one,
352  \$ b, ldb, a, lda )
353 *
354  ELSE IF( itype.EQ.3 ) THEN
355 *
356 * For B*A*x=(lambda)*x;
357 * backtransform eigenvectors: x = L*y or U**T*y
358 *
359  IF( upper ) THEN
360  trans = 'T'
361  ELSE
362  trans = 'N'
363  END IF
364 *
365  CALL dtrmm( 'Left', uplo, trans, 'Non-unit', n, n, one,
366  \$ b, ldb, a, lda )
367  END IF
368  END IF
369 *
370  work( 1 ) = lopt
371  iwork( 1 ) = liopt
372 *
373  RETURN
374 *
375 * End of DSYGVD
376 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine dtrsm(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B, LDB)
DTRSM
Definition: dtrsm.f:181
subroutine dtrmm(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B, LDB)
DTRMM
Definition: dtrmm.f:177
subroutine dpotrf(UPLO, N, A, LDA, INFO)
DPOTRF
Definition: dpotrf.f:107
subroutine dsygst(ITYPE, UPLO, N, A, LDA, B, LDB, INFO)
DSYGST
Definition: dsygst.f:127
subroutine dsyevd(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, IWORK, LIWORK, INFO)
DSYEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices
Definition: dsyevd.f:185
Here is the call graph for this function:
Here is the caller graph for this function: