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

SSTEMR

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

Purpose:
 SSTEMR computes selected eigenvalues and, optionally, eigenvectors
 of a real symmetric tridiagonal matrix T. Any such unreduced matrix has
 a well defined set of pairwise different real eigenvalues, the corresponding
 real eigenvectors are pairwise orthogonal.

 The spectrum may be computed either completely or partially by specifying
 either an interval (VL,VU] or a range of indices IL:IU for the desired
 eigenvalues.

 Depending on the number of desired eigenvalues, these are computed either
 by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are
 computed by the use of various suitable L D L^T factorizations near clusters
 of close eigenvalues (referred to as RRRs, Relatively Robust
 Representations). An informal sketch of the algorithm follows.

 For each unreduced block (submatrix) of T,
    (a) Compute T - sigma I  = L D L^T, so that L and D
        define all the wanted eigenvalues to high relative accuracy.
        This means that small relative changes in the entries of D and L
        cause only small relative changes in the eigenvalues and
        eigenvectors. The standard (unfactored) representation of the
        tridiagonal matrix T does not have this property in general.
    (b) Compute the eigenvalues to suitable accuracy.
        If the eigenvectors are desired, the algorithm attains full
        accuracy of the computed eigenvalues only right before
        the corresponding vectors have to be computed, see steps c) and d).
    (c) For each cluster of close eigenvalues, select a new
        shift close to the cluster, find a new factorization, and refine
        the shifted eigenvalues to suitable accuracy.
    (d) For each eigenvalue with a large enough relative separation compute
        the corresponding eigenvector by forming a rank revealing twisted
        factorization. Go back to (c) for any clusters that remain.

 For more details, see:
 - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations
   to compute orthogonal eigenvectors of symmetric tridiagonal matrices,"
   Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
 - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and
   Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
   2004.  Also LAPACK Working Note 154.
 - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric
   tridiagonal eigenvalue/eigenvector problem",
   Computer Science Division Technical Report No. UCB/CSD-97-971,
   UC Berkeley, May 1997.

 Further Details
 1.SSTEMR works only on machines which follow IEEE-754
 floating-point standard in their handling of infinities and NaNs.
 This permits the use of efficient inner loops avoiding a check for
 zero divisors.
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]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
          T. On exit, D is overwritten.
[in,out]E
          E is REAL array, dimension (N)
          On entry, the (N-1) subdiagonal elements of the tridiagonal
          matrix T in elements 1 to N-1 of E. E(N) need not be set on
          input, but is used internally as workspace.
          On exit, E is overwritten.
[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.
          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.
          Not referenced if RANGE = 'A' or 'V'.
[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', and if INFO = 0, then the first M columns of Z
          contain the orthonormal eigenvectors of the matrix T
          corresponding to the selected eigenvalues, with the i-th
          column of Z holding the eigenvector associated with W(i).
          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 can be computed with a workspace
          query by setting NZC = -1, see below.
[in]LDZ
          LDZ is INTEGER
          The leading dimension of the array Z.  LDZ >= 1, and if
          JOBZ = 'V', then LDZ >= max(1,N).
[in]NZC
          NZC is INTEGER
          The number of eigenvectors to be held in the array Z.
          If RANGE = 'A', then NZC >= max(1,N).
          If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].
          If RANGE = 'I', then NZC >= IU-IL+1.
          If NZC = -1, then a workspace query is assumed; the
          routine calculates the number of columns of the array Z that
          are needed to hold the eigenvectors.
          This value is returned as the first entry of the Z array, and
          no error message related to NZC is issued by XERBLA.
[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 computed eigenvector
          is nonzero only in elements ISUPPZ( 2*i-1 ) through
          ISUPPZ( 2*i ). This is relevant in the case when the matrix
          is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0.
[in,out]TRYRAC
          TRYRAC is LOGICAL
          If TRYRAC.EQ..TRUE., indicates that the code should check whether
          the tridiagonal matrix defines its eigenvalues to high relative
          accuracy.  If so, the code uses relative-accuracy preserving
          algorithms that might be (a bit) slower depending on the matrix.
          If the matrix does not define its eigenvalues to high relative
          accuracy, the code can uses possibly faster algorithms.
          If TRYRAC.EQ..FALSE., the code is not required to guarantee
          relatively accurate eigenvalues and can use the fastest possible
          techniques.
          On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix
          does not define its eigenvalues to high relative accuracy.
[out]WORK
          WORK is REAL array, dimension (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 >= max(1,18*N)
          if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.
          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the optimal size of the WORK array, returns
          this value as the first entry of the WORK array, and no error
          message related to LWORK is issued by XERBLA.
[out]IWORK
          IWORK is INTEGER array, dimension (LIWORK)
          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
[in]LIWORK
          LIWORK is INTEGER
          The dimension of the array IWORK.  LIWORK >= max(1,10*N)
          if the eigenvectors are desired, and LIWORK >= max(1,8*N)
          if only the eigenvalues are to be computed.
          If LIWORK = -1, then a workspace query is assumed; the
          routine only calculates the optimal size of the IWORK array,
          returns this value as the first entry of the IWORK array, and
          no error message related to LIWORK is issued by XERBLA.
[out]INFO
          INFO is INTEGER
          On exit, INFO
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value
          > 0:  if INFO = 1X, internal error in SLARRE,
                if INFO = 2X, internal error in SLARRV.
                Here, the digit X = ABS( IINFO ) < 10, where IINFO is
                the nonzero error code returned by SLARRE or
                SLARRV, respectively.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
June 2016
Contributors:
Beresford Parlett, University of California, Berkeley, USA
Jim Demmel, University of California, Berkeley, USA
Inderjit Dhillon, University of Texas, Austin, USA
Osni Marques, LBNL/NERSC, USA
Christof Voemel, University of California, Berkeley, USA

Definition at line 323 of file sstemr.f.

323 *
324 * -- LAPACK computational routine (version 3.6.1) --
325 * -- LAPACK is a software package provided by Univ. of Tennessee, --
326 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
327 * June 2016
328 *
329 * .. Scalar Arguments ..
330  CHARACTER jobz, range
331  LOGICAL tryrac
332  INTEGER il, info, iu, ldz, nzc, liwork, lwork, m, n
333  REAL vl, vu
334 * ..
335 * .. Array Arguments ..
336  INTEGER isuppz( * ), iwork( * )
337  REAL d( * ), e( * ), w( * ), work( * )
338  REAL z( ldz, * )
339 * ..
340 *
341 * =====================================================================
342 *
343 * .. Parameters ..
344  REAL zero, one, four, minrgp
345  parameter ( zero = 0.0e0, one = 1.0e0,
346  $ four = 4.0e0,
347  $ minrgp = 3.0e-3 )
348 * ..
349 * .. Local Scalars ..
350  LOGICAL alleig, indeig, lquery, valeig, wantz, zquery
351  INTEGER i, ibegin, iend, ifirst, iil, iindbl, iindw,
352  $ iindwk, iinfo, iinspl, iiu, ilast, in, indd,
353  $ inde2, inderr, indgp, indgrs, indwrk, itmp,
354  $ itmp2, j, jblk, jj, liwmin, lwmin, nsplit,
355  $ nzcmin, offset, wbegin, wend
356  REAL bignum, cs, eps, pivmin, r1, r2, rmax, rmin,
357  $ rtol1, rtol2, safmin, scale, smlnum, sn,
358  $ thresh, tmp, tnrm, wl, wu
359 * ..
360 * ..
361 * .. External Functions ..
362  LOGICAL lsame
363  REAL slamch, slanst
364  EXTERNAL lsame, slamch, slanst
365 * ..
366 * .. External Subroutines ..
367  EXTERNAL scopy, slae2, slaev2, slarrc, slarre, slarrj,
369 * ..
370 * .. Intrinsic Functions ..
371  INTRINSIC max, min, sqrt
372 * ..
373 * .. Executable Statements ..
374 *
375 * Test the input parameters.
376 *
377  wantz = lsame( jobz, 'V' )
378  alleig = lsame( range, 'A' )
379  valeig = lsame( range, 'V' )
380  indeig = lsame( range, 'I' )
381 *
382  lquery = ( ( lwork.EQ.-1 ).OR.( liwork.EQ.-1 ) )
383  zquery = ( nzc.EQ.-1 )
384 
385 * SSTEMR needs WORK of size 6*N, IWORK of size 3*N.
386 * In addition, SLARRE needs WORK of size 6*N, IWORK of size 5*N.
387 * Furthermore, SLARRV needs WORK of size 12*N, IWORK of size 7*N.
388  IF( wantz ) THEN
389  lwmin = 18*n
390  liwmin = 10*n
391  ELSE
392 * need less workspace if only the eigenvalues are wanted
393  lwmin = 12*n
394  liwmin = 8*n
395  ENDIF
396 
397  wl = zero
398  wu = zero
399  iil = 0
400  iiu = 0
401  nsplit = 0
402 
403  IF( valeig ) THEN
404 * We do not reference VL, VU in the cases RANGE = 'I','A'
405 * The interval (WL, WU] contains all the wanted eigenvalues.
406 * It is either given by the user or computed in SLARRE.
407  wl = vl
408  wu = vu
409  ELSEIF( indeig ) THEN
410 * We do not reference IL, IU in the cases RANGE = 'V','A'
411  iil = il
412  iiu = iu
413  ENDIF
414 *
415  info = 0
416  IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
417  info = -1
418  ELSE IF( .NOT.( alleig .OR. valeig .OR. indeig ) ) THEN
419  info = -2
420  ELSE IF( n.LT.0 ) THEN
421  info = -3
422  ELSE IF( valeig .AND. n.GT.0 .AND. wu.LE.wl ) THEN
423  info = -7
424  ELSE IF( indeig .AND. ( iil.LT.1 .OR. iil.GT.n ) ) THEN
425  info = -8
426  ELSE IF( indeig .AND. ( iiu.LT.iil .OR. iiu.GT.n ) ) THEN
427  info = -9
428  ELSE IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
429  info = -13
430  ELSE IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
431  info = -17
432  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
433  info = -19
434  END IF
435 *
436 * Get machine constants.
437 *
438  safmin = slamch( 'Safe minimum' )
439  eps = slamch( 'Precision' )
440  smlnum = safmin / eps
441  bignum = one / smlnum
442  rmin = sqrt( smlnum )
443  rmax = min( sqrt( bignum ), one / sqrt( sqrt( safmin ) ) )
444 *
445  IF( info.EQ.0 ) THEN
446  work( 1 ) = lwmin
447  iwork( 1 ) = liwmin
448 *
449  IF( wantz .AND. alleig ) THEN
450  nzcmin = n
451  ELSE IF( wantz .AND. valeig ) THEN
452  CALL slarrc( 'T', n, vl, vu, d, e, safmin,
453  $ nzcmin, itmp, itmp2, info )
454  ELSE IF( wantz .AND. indeig ) THEN
455  nzcmin = iiu-iil+1
456  ELSE
457 * WANTZ .EQ. FALSE.
458  nzcmin = 0
459  ENDIF
460  IF( zquery .AND. info.EQ.0 ) THEN
461  z( 1,1 ) = nzcmin
462  ELSE IF( nzc.LT.nzcmin .AND. .NOT.zquery ) THEN
463  info = -14
464  END IF
465  END IF
466 
467  IF( info.NE.0 ) THEN
468 *
469  CALL xerbla( 'SSTEMR', -info )
470 *
471  RETURN
472  ELSE IF( lquery .OR. zquery ) THEN
473  RETURN
474  END IF
475 *
476 * Handle N = 0, 1, and 2 cases immediately
477 *
478  m = 0
479  IF( n.EQ.0 )
480  $ RETURN
481 *
482  IF( n.EQ.1 ) THEN
483  IF( alleig .OR. indeig ) THEN
484  m = 1
485  w( 1 ) = d( 1 )
486  ELSE
487  IF( wl.LT.d( 1 ) .AND. wu.GE.d( 1 ) ) THEN
488  m = 1
489  w( 1 ) = d( 1 )
490  END IF
491  END IF
492  IF( wantz.AND.(.NOT.zquery) ) THEN
493  z( 1, 1 ) = one
494  isuppz(1) = 1
495  isuppz(2) = 1
496  END IF
497  RETURN
498  END IF
499 *
500  IF( n.EQ.2 ) THEN
501  IF( .NOT.wantz ) THEN
502  CALL slae2( d(1), e(1), d(2), r1, r2 )
503  ELSE IF( wantz.AND.(.NOT.zquery) ) THEN
504  CALL slaev2( d(1), e(1), d(2), r1, r2, cs, sn )
505  END IF
506  IF( alleig.OR.
507  $ (valeig.AND.(r2.GT.wl).AND.
508  $ (r2.LE.wu)).OR.
509  $ (indeig.AND.(iil.EQ.1)) ) THEN
510  m = m+1
511  w( m ) = r2
512  IF( wantz.AND.(.NOT.zquery) ) THEN
513  z( 1, m ) = -sn
514  z( 2, m ) = cs
515 * Note: At most one of SN and CS can be zero.
516  IF (sn.NE.zero) THEN
517  IF (cs.NE.zero) THEN
518  isuppz(2*m-1) = 1
519  isuppz(2*m) = 2
520  ELSE
521  isuppz(2*m-1) = 1
522  isuppz(2*m) = 1
523  END IF
524  ELSE
525  isuppz(2*m-1) = 2
526  isuppz(2*m) = 2
527  END IF
528  ENDIF
529  ENDIF
530  IF( alleig.OR.
531  $ (valeig.AND.(r1.GT.wl).AND.
532  $ (r1.LE.wu)).OR.
533  $ (indeig.AND.(iiu.EQ.2)) ) THEN
534  m = m+1
535  w( m ) = r1
536  IF( wantz.AND.(.NOT.zquery) ) THEN
537  z( 1, m ) = cs
538  z( 2, m ) = sn
539 * Note: At most one of SN and CS can be zero.
540  IF (sn.NE.zero) THEN
541  IF (cs.NE.zero) THEN
542  isuppz(2*m-1) = 1
543  isuppz(2*m) = 2
544  ELSE
545  isuppz(2*m-1) = 1
546  isuppz(2*m) = 1
547  END IF
548  ELSE
549  isuppz(2*m-1) = 2
550  isuppz(2*m) = 2
551  END IF
552  ENDIF
553  ENDIF
554  ELSE
555 
556 * Continue with general N
557 
558  indgrs = 1
559  inderr = 2*n + 1
560  indgp = 3*n + 1
561  indd = 4*n + 1
562  inde2 = 5*n + 1
563  indwrk = 6*n + 1
564 *
565  iinspl = 1
566  iindbl = n + 1
567  iindw = 2*n + 1
568  iindwk = 3*n + 1
569 *
570 * Scale matrix to allowable range, if necessary.
571 * The allowable range is related to the PIVMIN parameter; see the
572 * comments in SLARRD. The preference for scaling small values
573 * up is heuristic; we expect users' matrices not to be close to the
574 * RMAX threshold.
575 *
576  scale = one
577  tnrm = slanst( 'M', n, d, e )
578  IF( tnrm.GT.zero .AND. tnrm.LT.rmin ) THEN
579  scale = rmin / tnrm
580  ELSE IF( tnrm.GT.rmax ) THEN
581  scale = rmax / tnrm
582  END IF
583  IF( scale.NE.one ) THEN
584  CALL sscal( n, scale, d, 1 )
585  CALL sscal( n-1, scale, e, 1 )
586  tnrm = tnrm*scale
587  IF( valeig ) THEN
588 * If eigenvalues in interval have to be found,
589 * scale (WL, WU] accordingly
590  wl = wl*scale
591  wu = wu*scale
592  ENDIF
593  END IF
594 *
595 * Compute the desired eigenvalues of the tridiagonal after splitting
596 * into smaller subblocks if the corresponding off-diagonal elements
597 * are small
598 * THRESH is the splitting parameter for SLARRE
599 * A negative THRESH forces the old splitting criterion based on the
600 * size of the off-diagonal. A positive THRESH switches to splitting
601 * which preserves relative accuracy.
602 *
603  IF( tryrac ) THEN
604 * Test whether the matrix warrants the more expensive relative approach.
605  CALL slarrr( n, d, e, iinfo )
606  ELSE
607 * The user does not care about relative accurately eigenvalues
608  iinfo = -1
609  ENDIF
610 * Set the splitting criterion
611  IF (iinfo.EQ.0) THEN
612  thresh = eps
613  ELSE
614  thresh = -eps
615 * relative accuracy is desired but T does not guarantee it
616  tryrac = .false.
617  ENDIF
618 *
619  IF( tryrac ) THEN
620 * Copy original diagonal, needed to guarantee relative accuracy
621  CALL scopy(n,d,1,work(indd),1)
622  ENDIF
623 * Store the squares of the offdiagonal values of T
624  DO 5 j = 1, n-1
625  work( inde2+j-1 ) = e(j)**2
626  5 CONTINUE
627 
628 * Set the tolerance parameters for bisection
629  IF( .NOT.wantz ) THEN
630 * SLARRE computes the eigenvalues to full precision.
631  rtol1 = four * eps
632  rtol2 = four * eps
633  ELSE
634 * SLARRE computes the eigenvalues to less than full precision.
635 * SLARRV will refine the eigenvalue approximations, and we can
636 * need less accurate initial bisection in SLARRE.
637 * Note: these settings do only affect the subset case and SLARRE
638  rtol1 = max( sqrt(eps)*5.0e-2, four * eps )
639  rtol2 = max( sqrt(eps)*5.0e-3, four * eps )
640  ENDIF
641  CALL slarre( range, n, wl, wu, iil, iiu, d, e,
642  $ work(inde2), rtol1, rtol2, thresh, nsplit,
643  $ iwork( iinspl ), m, w, work( inderr ),
644  $ work( indgp ), iwork( iindbl ),
645  $ iwork( iindw ), work( indgrs ), pivmin,
646  $ work( indwrk ), iwork( iindwk ), iinfo )
647  IF( iinfo.NE.0 ) THEN
648  info = 10 + abs( iinfo )
649  RETURN
650  END IF
651 * Note that if RANGE .NE. 'V', SLARRE computes bounds on the desired
652 * part of the spectrum. All desired eigenvalues are contained in
653 * (WL,WU]
654 
655 
656  IF( wantz ) THEN
657 *
658 * Compute the desired eigenvectors corresponding to the computed
659 * eigenvalues
660 *
661  CALL slarrv( n, wl, wu, d, e,
662  $ pivmin, iwork( iinspl ), m,
663  $ 1, m, minrgp, rtol1, rtol2,
664  $ w, work( inderr ), work( indgp ), iwork( iindbl ),
665  $ iwork( iindw ), work( indgrs ), z, ldz,
666  $ isuppz, work( indwrk ), iwork( iindwk ), iinfo )
667  IF( iinfo.NE.0 ) THEN
668  info = 20 + abs( iinfo )
669  RETURN
670  END IF
671  ELSE
672 * SLARRE computes eigenvalues of the (shifted) root representation
673 * SLARRV returns the eigenvalues of the unshifted matrix.
674 * However, if the eigenvectors are not desired by the user, we need
675 * to apply the corresponding shifts from SLARRE to obtain the
676 * eigenvalues of the original matrix.
677  DO 20 j = 1, m
678  itmp = iwork( iindbl+j-1 )
679  w( j ) = w( j ) + e( iwork( iinspl+itmp-1 ) )
680  20 CONTINUE
681  END IF
682 *
683 
684  IF ( tryrac ) THEN
685 * Refine computed eigenvalues so that they are relatively accurate
686 * with respect to the original matrix T.
687  ibegin = 1
688  wbegin = 1
689  DO 39 jblk = 1, iwork( iindbl+m-1 )
690  iend = iwork( iinspl+jblk-1 )
691  in = iend - ibegin + 1
692  wend = wbegin - 1
693 * check if any eigenvalues have to be refined in this block
694  36 CONTINUE
695  IF( wend.LT.m ) THEN
696  IF( iwork( iindbl+wend ).EQ.jblk ) THEN
697  wend = wend + 1
698  GO TO 36
699  END IF
700  END IF
701  IF( wend.LT.wbegin ) THEN
702  ibegin = iend + 1
703  GO TO 39
704  END IF
705 
706  offset = iwork(iindw+wbegin-1)-1
707  ifirst = iwork(iindw+wbegin-1)
708  ilast = iwork(iindw+wend-1)
709  rtol2 = four * eps
710  CALL slarrj( in,
711  $ work(indd+ibegin-1), work(inde2+ibegin-1),
712  $ ifirst, ilast, rtol2, offset, w(wbegin),
713  $ work( inderr+wbegin-1 ),
714  $ work( indwrk ), iwork( iindwk ), pivmin,
715  $ tnrm, iinfo )
716  ibegin = iend + 1
717  wbegin = wend + 1
718  39 CONTINUE
719  ENDIF
720 *
721 * If matrix was scaled, then rescale eigenvalues appropriately.
722 *
723  IF( scale.NE.one ) THEN
724  CALL sscal( m, one / scale, w, 1 )
725  END IF
726  END IF
727 *
728 * If eigenvalues are not in increasing order, then sort them,
729 * possibly along with eigenvectors.
730 *
731  IF( nsplit.GT.1 .OR. n.EQ.2 ) THEN
732  IF( .NOT. wantz ) THEN
733  CALL slasrt( 'I', m, w, iinfo )
734  IF( iinfo.NE.0 ) THEN
735  info = 3
736  RETURN
737  END IF
738  ELSE
739  DO 60 j = 1, m - 1
740  i = 0
741  tmp = w( j )
742  DO 50 jj = j + 1, m
743  IF( w( jj ).LT.tmp ) THEN
744  i = jj
745  tmp = w( jj )
746  END IF
747  50 CONTINUE
748  IF( i.NE.0 ) THEN
749  w( i ) = w( j )
750  w( j ) = tmp
751  IF( wantz ) THEN
752  CALL sswap( n, z( 1, i ), 1, z( 1, j ), 1 )
753  itmp = isuppz( 2*i-1 )
754  isuppz( 2*i-1 ) = isuppz( 2*j-1 )
755  isuppz( 2*j-1 ) = itmp
756  itmp = isuppz( 2*i )
757  isuppz( 2*i ) = isuppz( 2*j )
758  isuppz( 2*j ) = itmp
759  END IF
760  END IF
761  60 CONTINUE
762  END IF
763  ENDIF
764 *
765 *
766  work( 1 ) = lwmin
767  iwork( 1 ) = liwmin
768  RETURN
769 *
770 * End of SSTEMR
771 *
subroutine slarrc(JOBT, N, VL, VU, D, E, PIVMIN, EIGCNT, LCNT, RCNT, INFO)
SLARRC computes the number of eigenvalues of the symmetric tridiagonal matrix.
Definition: slarrc.f:139
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 slarrj(N, D, E2, IFIRST, ILAST, RTOL, OFFSET, W, WERR, WORK, IWORK, PIVMIN, SPDIAM, INFO)
SLARRJ performs refinement of the initial estimates of the eigenvalues of the matrix T...
Definition: slarrj.f:170
subroutine slarrr(N, D, E, INFO)
SLARRR performs tests to decide whether the symmetric tridiagonal matrix T warrants expensive computa...
Definition: slarrr.f:96
subroutine slarre(RANGE, N, VL, VU, IL, IU, D, E, E2, RTOL1, RTOL2, SPLTOL, NSPLIT, ISPLIT, M, W, WERR, WGAP, IBLOCK, INDEXW, GERS, PIVMIN, WORK, IWORK, INFO)
SLARRE given the tridiagonal matrix T, sets small off-diagonal elements to zero and for each unreduce...
Definition: slarre.f:307
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine slaev2(A, B, C, RT1, RT2, CS1, SN1)
SLAEV2 computes the eigenvalues and eigenvectors of a 2-by-2 symmetric/Hermitian matrix.
Definition: slaev2.f:122
subroutine slasrt(ID, N, D, INFO)
SLASRT sorts numbers in increasing or decreasing order.
Definition: slasrt.f:90
subroutine slarrv(N, VL, VU, D, L, PIVMIN, ISPLIT, M, DOL, DOU, MINRGP, RTOL1, RTOL2, W, WERR, WGAP, IBLOCK, INDEXW, GERS, Z, LDZ, ISUPPZ, WORK, IWORK, INFO)
SLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and the eigenvalues ...
Definition: slarrv.f:288
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
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:53
subroutine slae2(A, B, C, RT1, RT2)
SLAE2 computes the eigenvalues of a 2-by-2 symmetric matrix.
Definition: slae2.f:104

Here is the call graph for this function:

Here is the caller graph for this function: