LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
subroutine sstevr ( character  JOBZ,
character  RANGE,
integer  N,
real, dimension( * )  D,
real, dimension( * )  E,
real  VL,
real  VU,
integer  IL,
integer  IU,
real  ABSTOL,
integer  M,
real, dimension( * )  W,
real, dimension( ldz, * )  Z,
integer  LDZ,
integer, dimension( * )  ISUPPZ,
real, dimension( * )  WORK,
integer  LWORK,
integer, dimension( * )  IWORK,
integer  LIWORK,
integer  INFO 
)

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

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

Purpose:
 SSTEVR computes selected eigenvalues and, optionally, eigenvectors
 of a real symmetric tridiagonal matrix T.  Eigenvalues and
 eigenvectors can be selected by specifying either a range of values
 or a range of indices for the desired eigenvalues.

 Whenever possible, SSTEVR calls SSTEMR to compute the
 eigenspectrum using Relatively Robust Representations.  SSTEMR
 computes eigenvalues by the dqds algorithm, while orthogonal
 eigenvectors are computed from various "good" L D L^T representations
 (also known as Relatively Robust Representations). Gram-Schmidt
 orthogonalization is avoided as far as possible. More specifically,
 the various steps of the algorithm are as follows. For the i-th
 unreduced block of T,
    (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T
         is a relatively robust representation,
    (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high
        relative accuracy by the dqds algorithm,
    (c) If there is a cluster of close eigenvalues, "choose" sigma_i
        close to the cluster, and go to step (a),
    (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T,
        compute the corresponding eigenvector by forming a
        rank-revealing twisted factorization.
 The desired accuracy of the output can be specified by the input
 parameter ABSTOL.

 For more details, see "A new O(n^2) algorithm for the symmetric
 tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon,
 Computer Science Division Technical Report No. UCB//CSD-97-971,
 UC Berkeley, May 1997.


 Note 1 : SSTEVR calls SSTEMR when the full spectrum is requested
 on machines which conform to the ieee-754 floating point standard.
 SSTEVR calls SSTEBZ and SSTEIN on non-ieee machines and
 when partial spectrum requests are made.

 Normal execution of SSTEMR may create NaNs and infinities and
 hence may abort due to a floating point exception in environments
 which do not handle NaNs and infinities in the ieee standard default
 manner.
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.
          For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and
          SSTEIN are called
[in]N
          N is INTEGER
          The order of the matrix.  N >= 0.
[in,out]D
          D is REAL array, dimension (N)
          On entry, the n diagonal elements of the tridiagonal matrix
          A.
          On exit, D may be multiplied by a constant factor chosen
          to avoid over/underflow in computing the eigenvalues.
[in,out]E
          E is REAL array, dimension (max(1,N-1))
          On entry, the (n-1) subdiagonal elements of the tridiagonal
          matrix A in elements 1 to N-1 of E.
          On exit, E may be multiplied by a constant factor chosen
          to avoid over/underflow in computing the eigenvalues.
[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 A to tridiagonal form.

          See "Computing Small Singular Values of Bidiagonal Matrices
          with Guaranteed High Relative Accuracy," by Demmel and
          Kahan, LAPACK Working Note #3.

          If high relative accuracy is important, set ABSTOL to
          SLAMCH( 'Safe minimum' ).  Doing so will guarantee that
          eigenvalues are computed to high relative accuracy when
          possible in future releases.  The current code does not
          make any guarantees about high relative accuracy, but
          future releases will. See J. Barlow and J. Demmel,
          "Computing Accurate Eigensystems of Scaled Diagonally
          Dominant Matrices", LAPACK Working Note #7, for a discussion
          of which matrices define their eigenvalues to high relative
          accuracy.
[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).
          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]ISUPPZ
          ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )
          The support of the eigenvectors in Z, i.e., the indices
          indicating the nonzero elements in Z. The i-th eigenvector
          is nonzero only in elements ISUPPZ( 2*i-1 ) through
          ISUPPZ( 2*i ).
          Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1
[out]WORK
          WORK is REAL array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal (and
          minimal) LWORK.
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK.  LWORK >= 20*N.

          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 (and
          minimal) LIWORK.
[in]LIWORK
          LIWORK is INTEGER
          The dimension of the array IWORK.  LIWORK >= 10*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:  Internal error
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
June 2016
Contributors:
Inderjit Dhillon, IBM Almaden, USA
Osni Marques, LBNL/NERSC, USA
Ken Stanley, Computer Science Division, University of California at Berkeley, USA
Jason Riedy, Computer Science Division, University of California at Berkeley, USA

Definition at line 308 of file sstevr.f.

308 *
309 * -- LAPACK driver routine (version 3.6.1) --
310 * -- LAPACK is a software package provided by Univ. of Tennessee, --
311 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
312 * June 2016
313 *
314 * .. Scalar Arguments ..
315  CHARACTER jobz, range
316  INTEGER il, info, iu, ldz, liwork, lwork, m, n
317  REAL abstol, vl, vu
318 * ..
319 * .. Array Arguments ..
320  INTEGER isuppz( * ), iwork( * )
321  REAL d( * ), e( * ), w( * ), work( * ), z( ldz, * )
322 * ..
323 *
324 * =====================================================================
325 *
326 * .. Parameters ..
327  REAL zero, one, two
328  parameter ( zero = 0.0e+0, one = 1.0e+0, two = 2.0e+0 )
329 * ..
330 * .. Local Scalars ..
331  LOGICAL alleig, indeig, test, lquery, valeig, wantz,
332  $ tryrac
333  CHARACTER order
334  INTEGER i, ieeeok, imax, indibl, indifl, indisp,
335  $ indiwo, iscale, j, jj, liwmin, lwmin, nsplit
336  REAL bignum, eps, rmax, rmin, safmin, sigma, smlnum,
337  $ tmp1, tnrm, vll, vuu
338 * ..
339 * .. External Functions ..
340  LOGICAL lsame
341  INTEGER ilaenv
342  REAL slamch, slanst
343  EXTERNAL lsame, ilaenv, slamch, slanst
344 * ..
345 * .. External Subroutines ..
346  EXTERNAL scopy, sscal, sstebz, sstemr, sstein, ssterf,
347  $ sswap, xerbla
348 * ..
349 * .. Intrinsic Functions ..
350  INTRINSIC max, min, sqrt
351 * ..
352 * .. Executable Statements ..
353 *
354 *
355 * Test the input parameters.
356 *
357  ieeeok = ilaenv( 10, 'SSTEVR', 'N', 1, 2, 3, 4 )
358 *
359  wantz = lsame( jobz, 'V' )
360  alleig = lsame( range, 'A' )
361  valeig = lsame( range, 'V' )
362  indeig = lsame( range, 'I' )
363 *
364  lquery = ( ( lwork.EQ.-1 ) .OR. ( liwork.EQ.-1 ) )
365  lwmin = max( 1, 20*n )
366  liwmin = max(1, 10*n )
367 *
368 *
369  info = 0
370  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
371  info = -1
372  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
373  info = -2
374  ELSE IF( n.LT.0 ) THEN
375  info = -3
376  ELSE
377  IF( valeig ) THEN
378  IF( n.GT.0 .AND. vu.LE.vl )
379  $ info = -7
380  ELSE IF( indeig ) THEN
381  IF( il.LT.1 .OR. il.GT.max( 1, n ) ) THEN
382  info = -8
383  ELSE IF( iu.LT.min( n, il ) .OR. iu.GT.n ) THEN
384  info = -9
385  END IF
386  END IF
387  END IF
388  IF( info.EQ.0 ) THEN
389  IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
390  info = -14
391  END IF
392  END IF
393 *
394  IF( info.EQ.0 ) THEN
395  work( 1 ) = lwmin
396  iwork( 1 ) = liwmin
397 *
398  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
399  info = -17
400  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
401  info = -19
402  END IF
403  END IF
404 *
405  IF( info.NE.0 ) THEN
406  CALL xerbla( 'SSTEVR', -info )
407  RETURN
408  ELSE IF( lquery ) THEN
409  RETURN
410  END IF
411 *
412 * Quick return if possible
413 *
414  m = 0
415  IF( n.EQ.0 )
416  $ RETURN
417 *
418  IF( n.EQ.1 ) THEN
419  IF( alleig .OR. indeig ) THEN
420  m = 1
421  w( 1 ) = d( 1 )
422  ELSE
423  IF( vl.LT.d( 1 ) .AND. vu.GE.d( 1 ) ) THEN
424  m = 1
425  w( 1 ) = d( 1 )
426  END IF
427  END IF
428  IF( wantz )
429  $ z( 1, 1 ) = one
430  RETURN
431  END IF
432 *
433 * Get machine constants.
434 *
435  safmin = slamch( 'Safe minimum' )
436  eps = slamch( 'Precision' )
437  smlnum = safmin / eps
438  bignum = one / smlnum
439  rmin = sqrt( smlnum )
440  rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
441 *
442 *
443 * Scale matrix to allowable range, if necessary.
444 *
445  iscale = 0
446  IF( valeig ) THEN
447  vll = vl
448  vuu = vu
449  END IF
450 *
451  tnrm = slanst( 'M', n, d, e )
452  IF( tnrm.GT.zero .AND. tnrm.LT.rmin ) THEN
453  iscale = 1
454  sigma = rmin / tnrm
455  ELSE IF( tnrm.GT.rmax ) THEN
456  iscale = 1
457  sigma = rmax / tnrm
458  END IF
459  IF( iscale.EQ.1 ) THEN
460  CALL sscal( n, sigma, d, 1 )
461  CALL sscal( n-1, sigma, e( 1 ), 1 )
462  IF( valeig ) THEN
463  vll = vl*sigma
464  vuu = vu*sigma
465  END IF
466  END IF
467 
468 * Initialize indices into workspaces. Note: These indices are used only
469 * if SSTERF or SSTEMR fail.
470 
471 * IWORK(INDIBL:INDIBL+M-1) corresponds to IBLOCK in SSTEBZ and
472 * stores the block indices of each of the M<=N eigenvalues.
473  indibl = 1
474 * IWORK(INDISP:INDISP+NSPLIT-1) corresponds to ISPLIT in SSTEBZ and
475 * stores the starting and finishing indices of each block.
476  indisp = indibl + n
477 * IWORK(INDIFL:INDIFL+N-1) stores the indices of eigenvectors
478 * that corresponding to eigenvectors that fail to converge in
479 * SSTEIN. This information is discarded; if any fail, the driver
480 * returns INFO > 0.
481  indifl = indisp + n
482 * INDIWO is the offset of the remaining integer workspace.
483  indiwo = indisp + n
484 *
485 * If all eigenvalues are desired, then
486 * call SSTERF or SSTEMR. If this fails for some eigenvalue, then
487 * try SSTEBZ.
488 *
489 *
490  test = .false.
491  IF( indeig ) THEN
492  IF( il.EQ.1 .AND. iu.EQ.n ) THEN
493  test = .true.
494  END IF
495  END IF
496  IF( ( alleig .OR. test ) .AND. ieeeok.EQ.1 ) THEN
497  CALL scopy( n-1, e( 1 ), 1, work( 1 ), 1 )
498  IF( .NOT.wantz ) THEN
499  CALL scopy( n, d, 1, w, 1 )
500  CALL ssterf( n, w, work, info )
501  ELSE
502  CALL scopy( n, d, 1, work( n+1 ), 1 )
503  IF (abstol .LE. two*n*eps) THEN
504  tryrac = .true.
505  ELSE
506  tryrac = .false.
507  END IF
508  CALL sstemr( jobz, 'A', n, work( n+1 ), work, vl, vu, il,
509  $ iu, m, w, z, ldz, n, isuppz, tryrac,
510  $ work( 2*n+1 ), lwork-2*n, iwork, liwork, info )
511 *
512  END IF
513  IF( info.EQ.0 ) THEN
514  m = n
515  GO TO 10
516  END IF
517  info = 0
518  END IF
519 *
520 * Otherwise, call SSTEBZ and, if eigenvectors are desired, SSTEIN.
521 *
522  IF( wantz ) THEN
523  order = 'B'
524  ELSE
525  order = 'E'
526  END IF
527 
528  CALL sstebz( range, order, n, vll, vuu, il, iu, abstol, d, e, m,
529  $ nsplit, w, iwork( indibl ), iwork( indisp ), work,
530  $ iwork( indiwo ), info )
531 *
532  IF( wantz ) THEN
533  CALL sstein( n, d, e, m, w, iwork( indibl ), iwork( indisp ),
534  $ z, ldz, work, iwork( indiwo ), iwork( indifl ),
535  $ info )
536  END IF
537 *
538 * If matrix was scaled, then rescale eigenvalues appropriately.
539 *
540  10 CONTINUE
541  IF( iscale.EQ.1 ) THEN
542  IF( info.EQ.0 ) THEN
543  imax = m
544  ELSE
545  imax = info - 1
546  END IF
547  CALL sscal( imax, one / sigma, w, 1 )
548  END IF
549 *
550 * If eigenvalues are not in order, then sort them, along with
551 * eigenvectors.
552 *
553  IF( wantz ) THEN
554  DO 30 j = 1, m - 1
555  i = 0
556  tmp1 = w( j )
557  DO 20 jj = j + 1, m
558  IF( w( jj ).LT.tmp1 ) THEN
559  i = jj
560  tmp1 = w( jj )
561  END IF
562  20 CONTINUE
563 *
564  IF( i.NE.0 ) THEN
565  w( i ) = w( j )
566  w( j ) = tmp1
567  CALL sswap( n, z( 1, i ), 1, z( 1, j ), 1 )
568  END IF
569  30 CONTINUE
570  END IF
571 *
572 * Causes problems with tests 19 & 20:
573 * IF (wantz .and. INDEIG ) Z( 1,1) = Z(1,1) / 1.002 + .002
574 *
575 *
576  work( 1 ) = lwmin
577  iwork( 1 ) = liwmin
578  RETURN
579 *
580 * End of SSTEVR
581 *
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
real function slanst(NORM, N, D, E)
SLANST returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix.
Definition: slanst.f:102
subroutine sstein(N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
SSTEIN
Definition: sstein.f:176
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
Definition: tstiee.f:83
subroutine sscal(N, SA, SX, INCX)
SSCAL
Definition: sscal.f:55
subroutine sswap(N, SX, INCX, SY, INCY)
SSWAP
Definition: sswap.f:53
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
subroutine ssterf(N, D, E, INFO)
SSTERF
Definition: ssterf.f:88
subroutine sstemr(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, M, W, Z, LDZ, NZC, ISUPPZ, TRYRAC, WORK, LWORK, IWORK, LIWORK, INFO)
SSTEMR
Definition: sstemr.f:323
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: