LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ ssygvd()

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

SSYGVD

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

Purpose:
 SSYGVD 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 REAL 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 REAL 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 REAL array, dimension (N)
          If INFO = 0, the eigenvalues in ascending order.
[out]WORK
          WORK is REAL 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:  SPOTRF or SSYEVD 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.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Further Details:
  Modified so that no backsubstitution is performed if SSYEVD 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 ssygvd.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  REAL A( LDA, * ), B( LDB, * ), W( * ), WORK( * )
239 * ..
240 *
241 * =====================================================================
242 *
243 * .. Parameters ..
244  REAL ONE
245  parameter( one = 1.0e+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 spotrf, ssyevd, ssygst, strmm, strsm, xerbla
258 * ..
259 * .. Intrinsic Functions ..
260  INTRINSIC max, real
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( 'SSYGVD', -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 spotrf( 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 ssygst( itype, uplo, n, a, lda, b, ldb, info )
331  CALL ssyevd( jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork,
332  $ info )
333  lopt = max( real( lopt ), real( work( 1 ) ) )
334  liopt = max( real( liopt ), real( 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 strsm( '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 strmm( '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 SSYGVD
376 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine spotrf(UPLO, N, A, LDA, INFO)
SPOTRF
Definition: spotrf.f:107
subroutine ssygst(ITYPE, UPLO, N, A, LDA, B, LDB, INFO)
SSYGST
Definition: ssygst.f:127
subroutine ssyevd(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, IWORK, LIWORK, INFO)
SSYEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices
Definition: ssyevd.f:183
subroutine strmm(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B, LDB)
STRMM
Definition: strmm.f:177
subroutine strsm(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B, LDB)
STRSM
Definition: strsm.f:181
Here is the call graph for this function:
Here is the caller graph for this function: