LAPACK  3.6.1 LAPACK: Linear Algebra PACKage
 subroutine ssbevx ( character JOBZ, character RANGE, character UPLO, integer N, integer KD, real, dimension( ldab, * ) AB, integer LDAB, 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 )

SSBEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrices

Purpose:
``` SSBEVX computes selected eigenvalues and, optionally, eigenvectors
of a real symmetric band matrix A.  Eigenvalues and eigenvectors can
be selected by specifying either 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 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] KD ``` KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 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 KD+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(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j; if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd). On exit, AB is overwritten by values generated during the reduction to tridiagonal form. If UPLO = 'U', the first superdiagonal and the diagonal of the tridiagonal matrix T are returned in rows KD and KD+1 of AB, and if UPLO = 'L', the diagonal and first subdiagonal of T are returned in the first two rows of AB.``` [in] LDAB ``` LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD + 1.``` [out] Q ``` Q is REAL array, dimension (LDQ, N) If JOBZ = 'V', the N-by-N orthogonal matrix used in the reduction 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 = 'V', then LDQ >= max(1,N).``` [in] VL ``` VL is REAL If RANGE='V', the lower bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.``` [in] VU ``` VU is REAL If RANGE='V', the upper bound of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = 'A' or 'I'.``` [in] IL ``` IL is INTEGER If RANGE='I', the index of the smallest eigenvalue 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] IU ``` IU is INTEGER If RANGE='I', the index of the largest eigenvalue 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 AB 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'). See "Computing Small Singular Values of Bidiagonal Matrices with Guaranteed High Relative Accuracy," by Demmel and Kahan, LAPACK Working Note #3.``` [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) The first M elements contain the selected eigenvalues in ascending order.``` [out] Z ``` Z is REAL array, dimension (LDZ, max(1,M)) If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). If an eigenvector fails to converge, then that column of Z contains the latest approximation to the eigenvector, and the index of the eigenvector is returned in IFAIL. If JOBZ = 'N', then Z is not referenced. Note: the user must ensure that at least max(1,M) columns are supplied in the array Z; if RANGE = 'V', the exact value of M is not known in advance and an upper bound must be used.``` [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 (7*N)` [out] IWORK ` IWORK is INTEGER array, dimension (5*N)` [out] IFAIL ``` IFAIL is INTEGER array, dimension (N) 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 eigenvectors 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. > 0: if INFO = i, then i eigenvectors failed to converge. Their indices are stored in array IFAIL.```
Date
June 2016

Definition at line 267 of file ssbevx.f.

267 *
268 * -- LAPACK driver routine (version 3.6.1) --
269 * -- LAPACK is a software package provided by Univ. of Tennessee, --
270 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
271 * June 2016
272 *
273 * .. Scalar Arguments ..
274  CHARACTER jobz, range, uplo
275  INTEGER il, info, iu, kd, ldab, ldq, ldz, m, n
276  REAL abstol, vl, vu
277 * ..
278 * .. Array Arguments ..
279  INTEGER ifail( * ), iwork( * )
280  REAL ab( ldab, * ), q( ldq, * ), w( * ), work( * ),
281  \$ z( ldz, * )
282 * ..
283 *
284 * =====================================================================
285 *
286 * .. Parameters ..
287  REAL zero, one
288  parameter ( zero = 0.0e0, one = 1.0e0 )
289 * ..
290 * .. Local Scalars ..
291  LOGICAL alleig, indeig, lower, test, valeig, wantz
292  CHARACTER order
293  INTEGER i, iinfo, imax, indd, inde, indee, indibl,
294  \$ indisp, indiwo, indwrk, iscale, itmp1, j, jj,
295  \$ nsplit
296  REAL abstll, anrm, bignum, eps, rmax, rmin, safmin,
297  \$ sigma, smlnum, tmp1, vll, vuu
298 * ..
299 * .. External Functions ..
300  LOGICAL lsame
301  REAL slamch, slansb
302  EXTERNAL lsame, slamch, slansb
303 * ..
304 * .. External Subroutines ..
305  EXTERNAL scopy, sgemv, slacpy, slascl, ssbtrd, sscal,
307 * ..
308 * .. Intrinsic Functions ..
309  INTRINSIC max, min, sqrt
310 * ..
311 * .. Executable Statements ..
312 *
313 * Test the input parameters.
314 *
315  wantz = lsame( jobz, 'V' )
316  alleig = lsame( range, 'A' )
317  valeig = lsame( range, 'V' )
318  indeig = lsame( range, 'I' )
319  lower = lsame( uplo, 'L' )
320 *
321  info = 0
322  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
323  info = -1
324  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
325  info = -2
326  ELSE IF( .NOT.( lower .OR. lsame( uplo, 'U' ) ) ) THEN
327  info = -3
328  ELSE IF( n.LT.0 ) THEN
329  info = -4
330  ELSE IF( kd.LT.0 ) THEN
331  info = -5
332  ELSE IF( ldab.LT.kd+1 ) THEN
333  info = -7
334  ELSE IF( wantz .AND. ldq.LT.max( 1, n ) ) THEN
335  info = -9
336  ELSE
337  IF( valeig ) THEN
338  IF( n.GT.0 .AND. vu.LE.vl )
339  \$ info = -11
340  ELSE IF( indeig ) THEN
341  IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
342  info = -12
343  ELSE IF( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
344  info = -13
345  END IF
346  END IF
347  END IF
348  IF( info.EQ.0 ) THEN
349  IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) )
350  \$ info = -18
351  END IF
352 *
353  IF( info.NE.0 ) THEN
354  CALL xerbla( 'SSBEVX', -info )
355  RETURN
356  END IF
357 *
358 * Quick return if possible
359 *
360  m = 0
361  IF( n.EQ.0 )
362  \$ RETURN
363 *
364  IF( n.EQ.1 ) THEN
365  m = 1
366  IF( lower ) THEN
367  tmp1 = ab( 1, 1 )
368  ELSE
369  tmp1 = ab( kd+1, 1 )
370  END IF
371  IF( valeig ) THEN
372  IF( .NOT.( vl.LT.tmp1 .AND. vu.GE.tmp1 ) )
373  \$ m = 0
374  END IF
375  IF( m.EQ.1 ) THEN
376  w( 1 ) = tmp1
377  IF( wantz )
378  \$ z( 1, 1 ) = one
379  END IF
380  RETURN
381  END IF
382 *
383 * Get machine constants.
384 *
385  safmin = slamch( 'Safe minimum' )
386  eps = slamch( 'Precision' )
387  smlnum = safmin / eps
388  bignum = one / smlnum
389  rmin = sqrt( smlnum )
390  rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
391 *
392 * Scale matrix to allowable range, if necessary.
393 *
394  iscale = 0
395  abstll = abstol
396  IF ( valeig ) THEN
397  vll = vl
398  vuu = vu
399  ELSE
400  vll = zero
401  vuu = zero
402  ENDIF
403  anrm = slansb( 'M', uplo, n, kd, ab, ldab, work )
404  IF( anrm.GT.zero .AND. anrm.LT.rmin ) THEN
405  iscale = 1
406  sigma = rmin / anrm
407  ELSE IF( anrm.GT.rmax ) THEN
408  iscale = 1
409  sigma = rmax / anrm
410  END IF
411  IF( iscale.EQ.1 ) THEN
412  IF( lower ) THEN
413  CALL slascl( 'B', kd, kd, one, sigma, n, n, ab, ldab, info )
414  ELSE
415  CALL slascl( 'Q', kd, kd, one, sigma, n, n, ab, ldab, info )
416  END IF
417  IF( abstol.GT.0 )
418  \$ abstll = abstol*sigma
419  IF( valeig ) THEN
420  vll = vl*sigma
421  vuu = vu*sigma
422  END IF
423  END IF
424 *
425 * Call SSBTRD to reduce symmetric band matrix to tridiagonal form.
426 *
427  indd = 1
428  inde = indd + n
429  indwrk = inde + n
430  CALL ssbtrd( jobz, uplo, n, kd, ab, ldab, work( indd ),
431  \$ work( inde ), q, ldq, work( indwrk ), iinfo )
432 *
433 * If all eigenvalues are desired and ABSTOL is less than or equal
434 * to zero, then call SSTERF or SSTEQR. If this fails for some
435 * eigenvalue, then try SSTEBZ.
436 *
437  test = .false.
438  IF (indeig) THEN
439  IF (il.EQ.1 .AND. iu.EQ.n) THEN
440  test = .true.
441  END IF
442  END IF
443  IF ((alleig .OR. test) .AND. (abstol.LE.zero)) THEN
444  CALL scopy( n, work( indd ), 1, w, 1 )
445  indee = indwrk + 2*n
446  IF( .NOT.wantz ) THEN
447  CALL scopy( n-1, work( inde ), 1, work( indee ), 1 )
448  CALL ssterf( n, w, work( indee ), info )
449  ELSE
450  CALL slacpy( 'A', n, n, q, ldq, z, ldz )
451  CALL scopy( n-1, work( inde ), 1, work( indee ), 1 )
452  CALL ssteqr( jobz, n, w, work( indee ), z, ldz,
453  \$ work( indwrk ), info )
454  IF( info.EQ.0 ) THEN
455  DO 10 i = 1, n
456  ifail( i ) = 0
457  10 CONTINUE
458  END IF
459  END IF
460  IF( info.EQ.0 ) THEN
461  m = n
462  GO TO 30
463  END IF
464  info = 0
465  END IF
466 *
467 * Otherwise, call SSTEBZ and, if eigenvectors are desired, SSTEIN.
468 *
469  IF( wantz ) THEN
470  order = 'B'
471  ELSE
472  order = 'E'
473  END IF
474  indibl = 1
475  indisp = indibl + n
476  indiwo = indisp + n
477  CALL sstebz( range, order, n, vll, vuu, il, iu, abstll,
478  \$ work( indd ), work( inde ), m, nsplit, w,
479  \$ iwork( indibl ), iwork( indisp ), work( indwrk ),
480  \$ iwork( indiwo ), info )
481 *
482  IF( wantz ) THEN
483  CALL sstein( n, work( indd ), work( inde ), m, w,
484  \$ iwork( indibl ), iwork( indisp ), z, ldz,
485  \$ work( indwrk ), iwork( indiwo ), ifail, info )
486 *
487 * Apply orthogonal matrix used in reduction to tridiagonal
488 * form to eigenvectors returned by SSTEIN.
489 *
490  DO 20 j = 1, m
491  CALL scopy( n, z( 1, j ), 1, work( 1 ), 1 )
492  CALL sgemv( 'N', n, n, one, q, ldq, work, 1, zero,
493  \$ z( 1, j ), 1 )
494  20 CONTINUE
495  END IF
496 *
497 * If matrix was scaled, then rescale eigenvalues appropriately.
498 *
499  30 CONTINUE
500  IF( iscale.EQ.1 ) THEN
501  IF( info.EQ.0 ) THEN
502  imax = m
503  ELSE
504  imax = info - 1
505  END IF
506  CALL sscal( imax, one / sigma, w, 1 )
507  END IF
508 *
509 * If eigenvalues are not in order, then sort them, along with
510 * eigenvectors.
511 *
512  IF( wantz ) THEN
513  DO 50 j = 1, m - 1
514  i = 0
515  tmp1 = w( j )
516  DO 40 jj = j + 1, m
517  IF( w( jj ).LT.tmp1 ) THEN
518  i = jj
519  tmp1 = w( jj )
520  END IF
521  40 CONTINUE
522 *
523  IF( i.NE.0 ) THEN
524  itmp1 = iwork( indibl+i-1 )
525  w( i ) = w( j )
526  iwork( indibl+i-1 ) = iwork( indibl+j-1 )
527  w( j ) = tmp1
528  iwork( indibl+j-1 ) = itmp1
529  CALL sswap( n, z( 1, i ), 1, z( 1, j ), 1 )
530  IF( info.NE.0 ) THEN
531  itmp1 = ifail( i )
532  ifail( i ) = ifail( j )
533  ifail( j ) = itmp1
534  END IF
535  END IF
536  50 CONTINUE
537  END IF
538 *
539  RETURN
540 *
541 * End of SSBEVX
542 *
subroutine sstebz(RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, INFO)
SSTEBZ
Definition: sstebz.f:275
subroutine sstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSTEIN
Definition: sstein.f:176
subroutine slascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
SLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: slascl.f:145
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
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
real function slansb(NORM, UPLO, N, K, AB, LDAB, WORK)
SLANSB returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a symmetric band matrix.
Definition: slansb.f:131
subroutine ssteqr(COMPZ, N, D, E, Z, LDZ, WORK, INFO)
SSTEQR
Definition: ssteqr.f:133
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:55
subroutine sswap(N, SX, INCX, SY, INCY)
SSWAP
Definition: sswap.f:53
subroutine ssbtrd(VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, WORK, INFO)
SSBTRD
Definition: ssbtrd.f:165
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:88
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:53

Here is the call graph for this function:

Here is the caller graph for this function: