LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ dsbgvd()

subroutine dsbgvd ( character  JOBZ,
character  UPLO,
integer  N,
integer  KA,
integer  KB,
double precision, dimension( ldab, * )  AB,
integer  LDAB,
double precision, dimension( ldbb, * )  BB,
integer  LDBB,
double precision, dimension( * )  W,
double precision, dimension( ldz, * )  Z,
integer  LDZ,
double precision, dimension( * )  WORK,
integer  LWORK,
integer, dimension( * )  IWORK,
integer  LIWORK,
integer  INFO 
)

DSBGVD

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

Purpose:
 DSBGVD computes all the eigenvalues, and optionally, the eigenvectors
 of a real generalized symmetric-definite banded eigenproblem, of the
 form A*x=(lambda)*B*x.  Here A and B are assumed to be symmetric and
 banded, 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]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]KA
          KA is INTEGER
          The number of superdiagonals of the matrix A if UPLO = 'U',
          or the number of subdiagonals if UPLO = 'L'.  KA >= 0.
[in]KB
          KB is INTEGER
          The number of superdiagonals of the matrix B if UPLO = 'U',
          or the number of subdiagonals if UPLO = 'L'.  KB >= 0.
[in,out]AB
          AB is DOUBLE PRECISION array, dimension (LDAB, N)
          On entry, the upper or lower triangle of the symmetric band
          matrix A, stored in the first ka+1 rows of the array.  The
          j-th column of A is stored in the j-th column of the array AB
          as follows:
          if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;
          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).

          On exit, the contents of AB are destroyed.
[in]LDAB
          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KA+1.
[in,out]BB
          BB is DOUBLE PRECISION array, dimension (LDBB, N)
          On entry, the upper or lower triangle of the symmetric band
          matrix B, stored in the first kb+1 rows of the array.  The
          j-th column of B is stored in the j-th column of the array BB
          as follows:
          if UPLO = 'U', BB(ka+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;
          if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).

          On exit, the factor S from the split Cholesky factorization
          B = S**T*S, as returned by DPBSTF.
[in]LDBB
          LDBB is INTEGER
          The leading dimension of the array BB.  LDBB >= KB+1.
[out]W
          W is DOUBLE PRECISION array, dimension (N)
          If INFO = 0, the eigenvalues in ascending order.
[out]Z
          Z is DOUBLE PRECISION array, dimension (LDZ, N)
          If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of
          eigenvectors, with the i-th column of Z holding the
          eigenvector associated with W(i).  The eigenvectors are
          normalized so Z**T*B*Z = I.
          If JOBZ = 'N', then Z is not referenced.
[in]LDZ
          LDZ is INTEGER
          The leading dimension of the array Z.  LDZ >= 1, and if
          JOBZ = 'V', LDZ >= max(1,N).
[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.
          If JOBZ = 'V' and N > 1, LWORK >= 1 + 5*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 LIWORK > 0, IWORK(1) returns the optimal LIWORK.
[in]LIWORK
          LIWORK is INTEGER
          The dimension of the array IWORK.
          If JOBZ  = 'N' or 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:  if INFO = i, and i is:
             <= N:  the algorithm failed to converge:
                    i off-diagonal elements of an intermediate
                    tridiagonal form did not converge to zero;
             > N:   if INFO = N + i, for 1 <= i <= N, then DPBSTF
                    returned INFO = i: 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.
Date
June 2016
Contributors:
Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

Definition at line 229 of file dsbgvd.f.

229 *
230 * -- LAPACK driver routine (version 3.7.0) --
231 * -- LAPACK is a software package provided by Univ. of Tennessee, --
232 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
233 * June 2016
234 *
235 * .. Scalar Arguments ..
236  CHARACTER jobz, uplo
237  INTEGER info, ka, kb, ldab, ldbb, ldz, liwork, lwork, n
238 * ..
239 * .. Array Arguments ..
240  INTEGER iwork( * )
241  DOUBLE PRECISION ab( ldab, * ), bb( ldbb, * ), w( * ),
242  $ work( * ), z( ldz, * )
243 * ..
244 *
245 * =====================================================================
246 *
247 * .. Parameters ..
248  DOUBLE PRECISION one, zero
249  parameter( one = 1.0d+0, zero = 0.0d+0 )
250 * ..
251 * .. Local Scalars ..
252  LOGICAL lquery, upper, wantz
253  CHARACTER vect
254  INTEGER iinfo, inde, indwk2, indwrk, liwmin, llwrk2,
255  $ lwmin
256 * ..
257 * .. External Functions ..
258  LOGICAL lsame
259  EXTERNAL lsame
260 * ..
261 * .. External Subroutines ..
262  EXTERNAL dgemm, dlacpy, dpbstf, dsbgst, dsbtrd, dstedc,
263  $ dsterf, xerbla
264 * ..
265 * .. Executable Statements ..
266 *
267 * Test the input parameters.
268 *
269  wantz = lsame( jobz, 'V' )
270  upper = lsame( uplo, 'U' )
271  lquery = ( lwork.EQ.-1 .OR. liwork.EQ.-1 )
272 *
273  info = 0
274  IF( n.LE.1 ) THEN
275  liwmin = 1
276  lwmin = 1
277  ELSE IF( wantz ) THEN
278  liwmin = 3 + 5*n
279  lwmin = 1 + 5*n + 2*n**2
280  ELSE
281  liwmin = 1
282  lwmin = 2*n
283  END IF
284 *
285  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
286  info = -1
287  ELSE IF( .NOT.( upper .OR. lsame( uplo, 'L' ) ) ) THEN
288  info = -2
289  ELSE IF( n.LT.0 ) THEN
290  info = -3
291  ELSE IF( ka.LT.0 ) THEN
292  info = -4
293  ELSE IF( kb.LT.0 .OR. kb.GT.ka ) THEN
294  info = -5
295  ELSE IF( ldab.LT.ka+1 ) THEN
296  info = -7
297  ELSE IF( ldbb.LT.kb+1 ) THEN
298  info = -9
299  ELSE IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
300  info = -12
301  END IF
302 *
303  IF( info.EQ.0 ) THEN
304  work( 1 ) = lwmin
305  iwork( 1 ) = liwmin
306 *
307  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
308  info = -14
309  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
310  info = -16
311  END IF
312  END IF
313 *
314  IF( info.NE.0 ) THEN
315  CALL xerbla( 'DSBGVD', -info )
316  RETURN
317  ELSE IF( lquery ) THEN
318  RETURN
319  END IF
320 *
321 * Quick return if possible
322 *
323  IF( n.EQ.0 )
324  $ RETURN
325 *
326 * Form a split Cholesky factorization of B.
327 *
328  CALL dpbstf( uplo, n, kb, bb, ldbb, info )
329  IF( info.NE.0 ) THEN
330  info = n + info
331  RETURN
332  END IF
333 *
334 * Transform problem to standard eigenvalue problem.
335 *
336  inde = 1
337  indwrk = inde + n
338  indwk2 = indwrk + n*n
339  llwrk2 = lwork - indwk2 + 1
340  CALL dsbgst( jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, z, ldz,
341  $ work, iinfo )
342 *
343 * Reduce to tridiagonal form.
344 *
345  IF( wantz ) THEN
346  vect = 'U'
347  ELSE
348  vect = 'N'
349  END IF
350  CALL dsbtrd( vect, uplo, n, ka, ab, ldab, w, work( inde ), z, ldz,
351  $ work( indwrk ), iinfo )
352 *
353 * For eigenvalues only, call DSTERF. For eigenvectors, call SSTEDC.
354 *
355  IF( .NOT.wantz ) THEN
356  CALL dsterf( n, w, work( inde ), info )
357  ELSE
358  CALL dstedc( 'I', n, w, work( inde ), work( indwrk ), n,
359  $ work( indwk2 ), llwrk2, iwork, liwork, info )
360  CALL dgemm( 'N', 'N', n, n, n, one, z, ldz, work( indwrk ), n,
361  $ zero, work( indwk2 ), n )
362  CALL dlacpy( 'A', n, n, work( indwk2 ), n, z, ldz )
363  END IF
364 *
365  work( 1 ) = lwmin
366  iwork( 1 ) = liwmin
367 *
368  RETURN
369 *
370 * End of DSBGVD
371 *
subroutine dsterf(N, D, E, INFO)
DSTERF
Definition: dsterf.f:88
subroutine dsbtrd(VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, WORK, INFO)
DSBTRD
Definition: dsbtrd.f:165
subroutine dstedc(COMPZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, LIWORK, INFO)
DSTEDC
Definition: dstedc.f:190
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine dgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
DGEMM
Definition: dgemm.f:189
subroutine dpbstf(UPLO, N, KD, AB, LDAB, INFO)
DPBSTF
Definition: dpbstf.f:154
subroutine dsbgst(VECT, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, X, LDX, WORK, INFO)
DSBGST
Definition: dsbgst.f:161
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:105
Here is the call graph for this function:
Here is the caller graph for this function: