LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
ssbgvx.f File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine ssbgvx (JOBZ, RANGE, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, Q, LDQ, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO)
 SSBGST More...
 

Function/Subroutine Documentation

subroutine ssbgvx ( character  JOBZ,
character  RANGE,
character  UPLO,
integer  N,
integer  KA,
integer  KB,
real, dimension( ldab, * )  AB,
integer  LDAB,
real, dimension( ldbb, * )  BB,
integer  LDBB,
real, dimension( ldq, * )  Q,
integer  LDQ,
real  VL,
real  VU,
integer  IL,
integer  IU,
real  ABSTOL,
integer  M,
real, dimension( * )  W,
real, dimension( ldz, * )  Z,
integer  LDZ,
real, dimension( * )  WORK,
integer, dimension( * )  IWORK,
integer, dimension( * )  IFAIL,
integer  INFO 
)

SSBGST

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

Purpose:
 SSBGVX computes selected eigenvalues, and optionally, 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.  Eigenvalues and
 eigenvectors can be selected by specifying either all eigenvalues,
 a range of values or a range of indices for the desired eigenvalues.
Parameters
[in]JOBZ
          JOBZ is CHARACTER*1
          = 'N':  Compute eigenvalues only;
          = 'V':  Compute eigenvalues and eigenvectors.
[in]RANGE
          RANGE is CHARACTER*1
          = 'A': all eigenvalues will be found.
          = 'V': all eigenvalues in the half-open interval (VL,VU]
                 will be found.
          = 'I': the IL-th through IU-th eigenvalues will be found.
[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 REAL 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 REAL 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 SPBSTF.
[in]LDBB
          LDBB is INTEGER
          The leading dimension of the array BB.  LDBB >= KB+1.
[out]Q
          Q is REAL array, dimension (LDQ, N)
          If JOBZ = 'V', the n-by-n matrix used in the reduction of
          A*x = (lambda)*B*x to standard form, i.e. C*x = (lambda)*x,
          and consequently C to tridiagonal form.
          If JOBZ = 'N', the array Q is not referenced.
[in]LDQ
          LDQ is INTEGER
          The leading dimension of the array Q.  If JOBZ = 'N',
          LDQ >= 1. If JOBZ = 'V', LDQ >= max(1,N).
[in]VL
          VL is REAL
[in]VU
          VU is REAL

          If RANGE='V', the lower and upper bounds of the interval to
          be searched for eigenvalues. VL < VU.
          Not referenced if RANGE = 'A' or 'I'.
[in]IL
          IL is INTEGER
[in]IU
          IU is INTEGER

          If RANGE='I', the indices (in ascending order) of the
          smallest and largest eigenvalues to be returned.
          1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.
          Not referenced if RANGE = 'A' or 'V'.
[in]ABSTOL
          ABSTOL is REAL
          The absolute error tolerance for the eigenvalues.
          An approximate eigenvalue is accepted as converged
          when it is determined to lie in an interval [a,b]
          of width less than or equal to

                  ABSTOL + EPS *   max( |a|,|b| ) ,

          where EPS is the machine precision.  If ABSTOL is less than
          or equal to zero, then  EPS*|T|  will be used in its place,
          where |T| is the 1-norm of the tridiagonal matrix obtained
          by reducing A to tridiagonal form.

          Eigenvalues will be computed most accurately when ABSTOL is
          set to twice the underflow threshold 2*SLAMCH('S'), not zero.
          If this routine returns with INFO>0, indicating that some
          eigenvectors did not converge, try setting ABSTOL to
          2*SLAMCH('S').
[out]M
          M is INTEGER
          The total number of eigenvalues found.  0 <= M <= N.
          If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.
[out]W
          W is REAL array, dimension (N)
          If INFO = 0, the eigenvalues in ascending order.
[out]Z
          Z is REAL 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 REAL array, dimension (7N)
[out]IWORK
          IWORK is INTEGER array, dimension (5N)
[out]IFAIL
          IFAIL is INTEGER array, dimension (M)
          If JOBZ = 'V', then if INFO = 0, the first M elements of
          IFAIL are zero.  If INFO > 0, then IFAIL contains the
          indices of the eigenvalues that failed to converge.
          If JOBZ = 'N', then IFAIL is not referenced.
[out]INFO
          INFO is INTEGER
          = 0 : successful exit
          < 0 : if INFO = -i, the i-th argument had an illegal value
          <= N: if INFO = i, then i eigenvectors failed to converge.
                  Their indices are stored in IFAIL.
          > N : SPBSTF returned an error code; i.e.,
                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.
Date
November 2011
Contributors:
Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

Definition at line 287 of file ssbgvx.f.

287 *
288 * -- LAPACK driver routine (version 3.4.0) --
289 * -- LAPACK is a software package provided by Univ. of Tennessee, --
290 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
291 * November 2011
292 *
293 * .. Scalar Arguments ..
294  CHARACTER jobz, range, uplo
295  INTEGER il, info, iu, ka, kb, ldab, ldbb, ldq, ldz, m,
296  $ n
297  REAL abstol, vl, vu
298 * ..
299 * .. Array Arguments ..
300  INTEGER ifail( * ), iwork( * )
301  REAL ab( ldab, * ), bb( ldbb, * ), q( ldq, * ),
302  $ w( * ), work( * ), z( ldz, * )
303 * ..
304 *
305 * =====================================================================
306 *
307 * .. Parameters ..
308  REAL zero, one
309  parameter( zero = 0.0e+0, one = 1.0e+0 )
310 * ..
311 * .. Local Scalars ..
312  LOGICAL alleig, indeig, test, upper, valeig, wantz
313  CHARACTER order, vect
314  INTEGER i, iinfo, indd, inde, indee, indibl, indisp,
315  $ indiwo, indwrk, itmp1, j, jj, nsplit
316  REAL tmp1
317 * ..
318 * .. External Functions ..
319  LOGICAL lsame
320  EXTERNAL lsame
321 * ..
322 * .. External Subroutines ..
323  EXTERNAL scopy, sgemv, slacpy, spbstf, ssbgst, ssbtrd,
325 * ..
326 * .. Intrinsic Functions ..
327  INTRINSIC min
328 * ..
329 * .. Executable Statements ..
330 *
331 * Test the input parameters.
332 *
333  wantz = lsame( jobz, 'V' )
334  upper = lsame( uplo, 'U' )
335  alleig = lsame( range, 'A' )
336  valeig = lsame( range, 'V' )
337  indeig = lsame( range, 'I' )
338 *
339  info = 0
340  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
341  info = -1
342  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
343  info = -2
344  ELSE IF( .NOT.( upper .OR. lsame( uplo, 'L' ) ) ) THEN
345  info = -3
346  ELSE IF( n.LT.0 ) THEN
347  info = -4
348  ELSE IF( ka.LT.0 ) THEN
349  info = -5
350  ELSE IF( kb.LT.0 .OR. kb.GT.ka ) THEN
351  info = -6
352  ELSE IF( ldab.LT.ka+1 ) THEN
353  info = -8
354  ELSE IF( ldbb.LT.kb+1 ) THEN
355  info = -10
356  ELSE IF( ldq.LT.1 .OR. ( wantz .AND. ldq.LT.n ) ) THEN
357  info = -12
358  ELSE
359  IF( valeig ) THEN
360  IF( n.GT.0 .AND. vu.LE.vl )
361  $ info = -14
362  ELSE IF( indeig ) THEN
363  IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
364  info = -15
365  ELSE IF ( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
366  info = -16
367  END IF
368  END IF
369  END IF
370  IF( info.EQ.0) THEN
371  IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
372  info = -21
373  END IF
374  END IF
375 *
376  IF( info.NE.0 ) THEN
377  CALL xerbla( 'SSBGVX', -info )
378  RETURN
379  END IF
380 *
381 * Quick return if possible
382 *
383  m = 0
384  IF( n.EQ.0 )
385  $ RETURN
386 *
387 * Form a split Cholesky factorization of B.
388 *
389  CALL spbstf( uplo, n, kb, bb, ldbb, info )
390  IF( info.NE.0 ) THEN
391  info = n + info
392  RETURN
393  END IF
394 *
395 * Transform problem to standard eigenvalue problem.
396 *
397  CALL ssbgst( jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq,
398  $ work, iinfo )
399 *
400 * Reduce symmetric band matrix to tridiagonal form.
401 *
402  indd = 1
403  inde = indd + n
404  indwrk = inde + n
405  IF( wantz ) THEN
406  vect = 'U'
407  ELSE
408  vect = 'N'
409  END IF
410  CALL ssbtrd( vect, uplo, n, ka, ab, ldab, work( indd ),
411  $ work( inde ), q, ldq, work( indwrk ), iinfo )
412 *
413 * If all eigenvalues are desired and ABSTOL is less than or equal
414 * to zero, then call SSTERF or SSTEQR. If this fails for some
415 * eigenvalue, then try SSTEBZ.
416 *
417  test = .false.
418  IF( indeig ) THEN
419  IF( il.EQ.1 .AND. iu.EQ.n ) THEN
420  test = .true.
421  END IF
422  END IF
423  IF( ( alleig .OR. test ) .AND. ( abstol.LE.zero ) ) THEN
424  CALL scopy( n, work( indd ), 1, w, 1 )
425  indee = indwrk + 2*n
426  CALL scopy( n-1, work( inde ), 1, work( indee ), 1 )
427  IF( .NOT.wantz ) THEN
428  CALL ssterf( n, w, work( indee ), info )
429  ELSE
430  CALL slacpy( 'A', n, n, q, ldq, z, ldz )
431  CALL ssteqr( jobz, n, w, work( indee ), z, ldz,
432  $ work( indwrk ), info )
433  IF( info.EQ.0 ) THEN
434  DO 10 i = 1, n
435  ifail( i ) = 0
436  10 CONTINUE
437  END IF
438  END IF
439  IF( info.EQ.0 ) THEN
440  m = n
441  GO TO 30
442  END IF
443  info = 0
444  END IF
445 *
446 * Otherwise, call SSTEBZ and, if eigenvectors are desired,
447 * call SSTEIN.
448 *
449  IF( wantz ) THEN
450  order = 'B'
451  ELSE
452  order = 'E'
453  END IF
454  indibl = 1
455  indisp = indibl + n
456  indiwo = indisp + n
457  CALL sstebz( range, order, n, vl, vu, il, iu, abstol,
458  $ work( indd ), work( inde ), m, nsplit, w,
459  $ iwork( indibl ), iwork( indisp ), work( indwrk ),
460  $ iwork( indiwo ), info )
461 *
462  IF( wantz ) THEN
463  CALL sstein( n, work( indd ), work( inde ), m, w,
464  $ iwork( indibl ), iwork( indisp ), z, ldz,
465  $ work( indwrk ), iwork( indiwo ), ifail, info )
466 *
467 * Apply transformation matrix used in reduction to tridiagonal
468 * form to eigenvectors returned by SSTEIN.
469 *
470  DO 20 j = 1, m
471  CALL scopy( n, z( 1, j ), 1, work( 1 ), 1 )
472  CALL sgemv( 'N', n, n, one, q, ldq, work, 1, zero,
473  $ z( 1, j ), 1 )
474  20 CONTINUE
475  END IF
476 *
477  30 CONTINUE
478 *
479 * If eigenvalues are not in order, then sort them, along with
480 * eigenvectors.
481 *
482  IF( wantz ) THEN
483  DO 50 j = 1, m - 1
484  i = 0
485  tmp1 = w( j )
486  DO 40 jj = j + 1, m
487  IF( w( jj ).LT.tmp1 ) THEN
488  i = jj
489  tmp1 = w( jj )
490  END IF
491  40 CONTINUE
492 *
493  IF( i.NE.0 ) THEN
494  itmp1 = iwork( indibl+i-1 )
495  w( i ) = w( j )
496  iwork( indibl+i-1 ) = iwork( indibl+j-1 )
497  w( j ) = tmp1
498  iwork( indibl+j-1 ) = itmp1
499  CALL sswap( n, z( 1, i ), 1, z( 1, j ), 1 )
500  IF( info.NE.0 ) THEN
501  itmp1 = ifail( i )
502  ifail( i ) = ifail( j )
503  ifail( j ) = itmp1
504  END IF
505  END IF
506  50 CONTINUE
507  END IF
508 *
509  RETURN
510 *
511 * End of SSBGVX
512 *
subroutine sswap(N, SX, INCX, SY, INCY)
SSWAP
Definition: sswap.f:53
subroutine spbstf(UPLO, N, KD, AB, LDAB, INFO)
SPBSTF
Definition: spbstf.f:154
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:53
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine sstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSTEIN
Definition: sstein.f:176
subroutine sgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
SGEMV
Definition: sgemv.f:158
subroutine slacpy(UPLO, M, N, A, LDA, B, LDB)
SLACPY copies all or part of one two-dimensional array to another.
Definition: slacpy.f:105
subroutine sstebz(RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, INFO)
SSTEBZ
Definition: sstebz.f:265
subroutine ssbgst(VECT, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, X, LDX, WORK, INFO)
SSBGST
Definition: ssbgst.f:161
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:88
subroutine ssteqr(COMPZ, N, D, E, Z, LDZ, WORK, INFO)
SSTEQR
Definition: ssteqr.f:133
subroutine ssbtrd(VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, WORK, INFO)
SSBTRD
Definition: ssbtrd.f:165

Here is the call graph for this function:

Here is the caller graph for this function: