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

Go to the source code of this file.

Functions/Subroutines

subroutine sstebz (RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, INFO)
 SSTEBZ More...
 

Function/Subroutine Documentation

subroutine sstebz ( character  RANGE,
character  ORDER,
integer  N,
real  VL,
real  VU,
integer  IL,
integer  IU,
real  ABSTOL,
real, dimension( * )  D,
real, dimension( * )  E,
integer  M,
integer  NSPLIT,
real, dimension( * )  W,
integer, dimension( * )  IBLOCK,
integer, dimension( * )  ISPLIT,
real, dimension( * )  WORK,
integer, dimension( * )  IWORK,
integer  INFO 
)

SSTEBZ

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

Purpose:
 SSTEBZ computes the eigenvalues of a symmetric tridiagonal
 matrix T.  The user may ask for all eigenvalues, all eigenvalues
 in the half-open interval (VL, VU], or the IL-th through IU-th
 eigenvalues.

 To avoid overflow, the matrix must be scaled so that its
 largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest
 accuracy, it should not be much smaller than that.

 See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal
 Matrix", Report CS41, Computer Science Dept., Stanford
 University, July 21, 1966.
Parameters
[in]RANGE
          RANGE is CHARACTER*1
          = 'A': ("All")   all eigenvalues will be found.
          = 'V': ("Value") all eigenvalues in the half-open interval
                           (VL, VU] will be found.
          = 'I': ("Index") the IL-th through IU-th eigenvalues (of the
                           entire matrix) will be found.
[in]ORDER
          ORDER is CHARACTER*1
          = 'B': ("By Block") the eigenvalues will be grouped by
                              split-off block (see IBLOCK, ISPLIT) and
                              ordered from smallest to largest within
                              the block.
          = 'E': ("Entire matrix")
                              the eigenvalues for the entire matrix
                              will be ordered from smallest to
                              largest.
[in]N
          N is INTEGER
          The order of the tridiagonal matrix T.  N >= 0.
[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.  Eigenvalues less than or equal
          to VL, or greater than VU, will not be returned.  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 tolerance for the eigenvalues.  An eigenvalue
          (or cluster) is considered to be located if it has been
          determined to lie in an interval whose width is ABSTOL or
          less.  If ABSTOL is less than or equal to zero, then ULP*|T|
          will be used, where |T| means the 1-norm of T.

          Eigenvalues will be computed most accurately when ABSTOL is
          set to twice the underflow threshold 2*SLAMCH('S'), not zero.
[in]D
          D is REAL array, dimension (N)
          The n diagonal elements of the tridiagonal matrix T.
[in]E
          E is REAL array, dimension (N-1)
          The (n-1) off-diagonal elements of the tridiagonal matrix T.
[out]M
          M is INTEGER
          The actual number of eigenvalues found. 0 <= M <= N.
          (See also the description of INFO=2,3.)
[out]NSPLIT
          NSPLIT is INTEGER
          The number of diagonal blocks in the matrix T.
          1 <= NSPLIT <= N.
[out]W
          W is REAL array, dimension (N)
          On exit, the first M elements of W will contain the
          eigenvalues.  (SSTEBZ may use the remaining N-M elements as
          workspace.)
[out]IBLOCK
          IBLOCK is INTEGER array, dimension (N)
          At each row/column j where E(j) is zero or small, the
          matrix T is considered to split into a block diagonal
          matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which
          block (from 1 to the number of blocks) the eigenvalue W(i)
          belongs.  (SSTEBZ may use the remaining N-M elements as
          workspace.)
[out]ISPLIT
          ISPLIT is INTEGER array, dimension (N)
          The splitting points, at which T breaks up into submatrices.
          The first submatrix consists of rows/columns 1 to ISPLIT(1),
          the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),
          etc., and the NSPLIT-th consists of rows/columns
          ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.
          (Only the first NSPLIT elements will actually be used, but
          since the user cannot know a priori what value NSPLIT will
          have, N words must be reserved for ISPLIT.)
[out]WORK
          WORK is REAL array, dimension (4*N)
[out]IWORK
          IWORK is INTEGER array, dimension (3*N)
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value
          > 0:  some or all of the eigenvalues failed to converge or
                were not computed:
                =1 or 3: Bisection failed to converge for some
                        eigenvalues; these eigenvalues are flagged by a
                        negative block number.  The effect is that the
                        eigenvalues may not be as accurate as the
                        absolute and relative tolerances.  This is
                        generally caused by unexpectedly inaccurate
                        arithmetic.
                =2 or 3: RANGE='I' only: Not all of the eigenvalues
                        IL:IU were found.
                        Effect: M < IU+1-IL
                        Cause:  non-monotonic arithmetic, causing the
                                Sturm sequence to be non-monotonic.
                        Cure:   recalculate, using RANGE='A', and pick
                                out eigenvalues IL:IU.  In some cases,
                                increasing the PARAMETER "FUDGE" may
                                make things work.
                = 4:    RANGE='I', and the Gershgorin interval
                        initially used was too small.  No eigenvalues
                        were computed.
                        Probable cause: your machine has sloppy
                                        floating-point arithmetic.
                        Cure: Increase the PARAMETER "FUDGE",
                              recompile, and try again.
Internal Parameters:
  RELFAC  REAL, default = 2.0e0
          The relative tolerance.  An interval (a,b] lies within
          "relative tolerance" if  b-a < RELFAC*ulp*max(|a|,|b|),
          where "ulp" is the machine precision (distance from 1 to
          the next larger floating point number.)

  FUDGE   REAL, default = 2
          A "fudge factor" to widen the Gershgorin intervals.  Ideally,
          a value of 1 should work, but on machines with sloppy
          arithmetic, this needs to be larger.  The default for
          publicly released versions should be large enough to handle
          the worst machine around.  Note that this has no effect
          on accuracy of the solution.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
November 2011

Definition at line 265 of file sstebz.f.

265 *
266 * -- LAPACK computational routine (version 3.4.0) --
267 * -- LAPACK is a software package provided by Univ. of Tennessee, --
268 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
269 * November 2011
270 *
271 * .. Scalar Arguments ..
272  CHARACTER order, range
273  INTEGER il, info, iu, m, n, nsplit
274  REAL abstol, vl, vu
275 * ..
276 * .. Array Arguments ..
277  INTEGER iblock( * ), isplit( * ), iwork( * )
278  REAL d( * ), e( * ), w( * ), work( * )
279 * ..
280 *
281 * =====================================================================
282 *
283 * .. Parameters ..
284  REAL zero, one, two, half
285  parameter( zero = 0.0e0, one = 1.0e0, two = 2.0e0,
286  $ half = 1.0e0 / two )
287  REAL fudge, relfac
288  parameter( fudge = 2.1e0, relfac = 2.0e0 )
289 * ..
290 * .. Local Scalars ..
291  LOGICAL ncnvrg, toofew
292  INTEGER ib, ibegin, idiscl, idiscu, ie, iend, iinfo,
293  $ im, in, ioff, iorder, iout, irange, itmax,
294  $ itmp1, iw, iwoff, j, jb, jdisc, je, nb, nwl,
295  $ nwu
296  REAL atoli, bnorm, gl, gu, pivmin, rtoli, safemn,
297  $ tmp1, tmp2, tnorm, ulp, wkill, wl, wlu, wu, wul
298 * ..
299 * .. Local Arrays ..
300  INTEGER idumma( 1 )
301 * ..
302 * .. External Functions ..
303  LOGICAL lsame
304  INTEGER ilaenv
305  REAL slamch
306  EXTERNAL lsame, ilaenv, slamch
307 * ..
308 * .. External Subroutines ..
309  EXTERNAL slaebz, xerbla
310 * ..
311 * .. Intrinsic Functions ..
312  INTRINSIC abs, int, log, max, min, sqrt
313 * ..
314 * .. Executable Statements ..
315 *
316  info = 0
317 *
318 * Decode RANGE
319 *
320  IF( lsame( range, 'A' ) ) THEN
321  irange = 1
322  ELSE IF( lsame( range, 'V' ) ) THEN
323  irange = 2
324  ELSE IF( lsame( range, 'I' ) ) THEN
325  irange = 3
326  ELSE
327  irange = 0
328  END IF
329 *
330 * Decode ORDER
331 *
332  IF( lsame( order, 'B' ) ) THEN
333  iorder = 2
334  ELSE IF( lsame( order, 'E' ) ) THEN
335  iorder = 1
336  ELSE
337  iorder = 0
338  END IF
339 *
340 * Check for Errors
341 *
342  IF( irange.LE.0 ) THEN
343  info = -1
344  ELSE IF( iorder.LE.0 ) THEN
345  info = -2
346  ELSE IF( n.LT.0 ) THEN
347  info = -3
348  ELSE IF( irange.EQ.2 ) THEN
349  IF( vl.GE.vu ) info = -5
350  ELSE IF( irange.EQ.3 .AND. ( il.LT.1 .OR. il.GT.max( 1, n ) ) )
351  $ THEN
352  info = -6
353  ELSE IF( irange.EQ.3 .AND. ( iu.LT.min( n, il ) .OR. iu.GT.n ) )
354  $ THEN
355  info = -7
356  END IF
357 *
358  IF( info.NE.0 ) THEN
359  CALL xerbla( 'SSTEBZ', -info )
360  RETURN
361  END IF
362 *
363 * Initialize error flags
364 *
365  info = 0
366  ncnvrg = .false.
367  toofew = .false.
368 *
369 * Quick return if possible
370 *
371  m = 0
372  IF( n.EQ.0 )
373  $ RETURN
374 *
375 * Simplifications:
376 *
377  IF( irange.EQ.3 .AND. il.EQ.1 .AND. iu.EQ.n )
378  $ irange = 1
379 *
380 * Get machine constants
381 * NB is the minimum vector length for vector bisection, or 0
382 * if only scalar is to be done.
383 *
384  safemn = slamch( 'S' )
385  ulp = slamch( 'P' )
386  rtoli = ulp*relfac
387  nb = ilaenv( 1, 'SSTEBZ', ' ', n, -1, -1, -1 )
388  IF( nb.LE.1 )
389  $ nb = 0
390 *
391 * Special Case when N=1
392 *
393  IF( n.EQ.1 ) THEN
394  nsplit = 1
395  isplit( 1 ) = 1
396  IF( irange.EQ.2 .AND. ( vl.GE.d( 1 ) .OR. vu.LT.d( 1 ) ) ) THEN
397  m = 0
398  ELSE
399  w( 1 ) = d( 1 )
400  iblock( 1 ) = 1
401  m = 1
402  END IF
403  RETURN
404  END IF
405 *
406 * Compute Splitting Points
407 *
408  nsplit = 1
409  work( n ) = zero
410  pivmin = one
411 *
412  DO 10 j = 2, n
413  tmp1 = e( j-1 )**2
414  IF( abs( d( j )*d( j-1 ) )*ulp**2+safemn.GT.tmp1 ) THEN
415  isplit( nsplit ) = j - 1
416  nsplit = nsplit + 1
417  work( j-1 ) = zero
418  ELSE
419  work( j-1 ) = tmp1
420  pivmin = max( pivmin, tmp1 )
421  END IF
422  10 CONTINUE
423  isplit( nsplit ) = n
424  pivmin = pivmin*safemn
425 *
426 * Compute Interval and ATOLI
427 *
428  IF( irange.EQ.3 ) THEN
429 *
430 * RANGE='I': Compute the interval containing eigenvalues
431 * IL through IU.
432 *
433 * Compute Gershgorin interval for entire (split) matrix
434 * and use it as the initial interval
435 *
436  gu = d( 1 )
437  gl = d( 1 )
438  tmp1 = zero
439 *
440  DO 20 j = 1, n - 1
441  tmp2 = sqrt( work( j ) )
442  gu = max( gu, d( j )+tmp1+tmp2 )
443  gl = min( gl, d( j )-tmp1-tmp2 )
444  tmp1 = tmp2
445  20 CONTINUE
446 *
447  gu = max( gu, d( n )+tmp1 )
448  gl = min( gl, d( n )-tmp1 )
449  tnorm = max( abs( gl ), abs( gu ) )
450  gl = gl - fudge*tnorm*ulp*n - fudge*two*pivmin
451  gu = gu + fudge*tnorm*ulp*n + fudge*pivmin
452 *
453 * Compute Iteration parameters
454 *
455  itmax = int( ( log( tnorm+pivmin )-log( pivmin ) ) /
456  $ log( two ) ) + 2
457  IF( abstol.LE.zero ) THEN
458  atoli = ulp*tnorm
459  ELSE
460  atoli = abstol
461  END IF
462 *
463  work( n+1 ) = gl
464  work( n+2 ) = gl
465  work( n+3 ) = gu
466  work( n+4 ) = gu
467  work( n+5 ) = gl
468  work( n+6 ) = gu
469  iwork( 1 ) = -1
470  iwork( 2 ) = -1
471  iwork( 3 ) = n + 1
472  iwork( 4 ) = n + 1
473  iwork( 5 ) = il - 1
474  iwork( 6 ) = iu
475 *
476  CALL slaebz( 3, itmax, n, 2, 2, nb, atoli, rtoli, pivmin, d, e,
477  $ work, iwork( 5 ), work( n+1 ), work( n+5 ), iout,
478  $ iwork, w, iblock, iinfo )
479 *
480  IF( iwork( 6 ).EQ.iu ) THEN
481  wl = work( n+1 )
482  wlu = work( n+3 )
483  nwl = iwork( 1 )
484  wu = work( n+4 )
485  wul = work( n+2 )
486  nwu = iwork( 4 )
487  ELSE
488  wl = work( n+2 )
489  wlu = work( n+4 )
490  nwl = iwork( 2 )
491  wu = work( n+3 )
492  wul = work( n+1 )
493  nwu = iwork( 3 )
494  END IF
495 *
496  IF( nwl.LT.0 .OR. nwl.GE.n .OR. nwu.LT.1 .OR. nwu.GT.n ) THEN
497  info = 4
498  RETURN
499  END IF
500  ELSE
501 *
502 * RANGE='A' or 'V' -- Set ATOLI
503 *
504  tnorm = max( abs( d( 1 ) )+abs( e( 1 ) ),
505  $ abs( d( n ) )+abs( e( n-1 ) ) )
506 *
507  DO 30 j = 2, n - 1
508  tnorm = max( tnorm, abs( d( j ) )+abs( e( j-1 ) )+
509  $ abs( e( j ) ) )
510  30 CONTINUE
511 *
512  IF( abstol.LE.zero ) THEN
513  atoli = ulp*tnorm
514  ELSE
515  atoli = abstol
516  END IF
517 *
518  IF( irange.EQ.2 ) THEN
519  wl = vl
520  wu = vu
521  ELSE
522  wl = zero
523  wu = zero
524  END IF
525  END IF
526 *
527 * Find Eigenvalues -- Loop Over Blocks and recompute NWL and NWU.
528 * NWL accumulates the number of eigenvalues .le. WL,
529 * NWU accumulates the number of eigenvalues .le. WU
530 *
531  m = 0
532  iend = 0
533  info = 0
534  nwl = 0
535  nwu = 0
536 *
537  DO 70 jb = 1, nsplit
538  ioff = iend
539  ibegin = ioff + 1
540  iend = isplit( jb )
541  in = iend - ioff
542 *
543  IF( in.EQ.1 ) THEN
544 *
545 * Special Case -- IN=1
546 *
547  IF( irange.EQ.1 .OR. wl.GE.d( ibegin )-pivmin )
548  $ nwl = nwl + 1
549  IF( irange.EQ.1 .OR. wu.GE.d( ibegin )-pivmin )
550  $ nwu = nwu + 1
551  IF( irange.EQ.1 .OR. ( wl.LT.d( ibegin )-pivmin .AND. wu.GE.
552  $ d( ibegin )-pivmin ) ) THEN
553  m = m + 1
554  w( m ) = d( ibegin )
555  iblock( m ) = jb
556  END IF
557  ELSE
558 *
559 * General Case -- IN > 1
560 *
561 * Compute Gershgorin Interval
562 * and use it as the initial interval
563 *
564  gu = d( ibegin )
565  gl = d( ibegin )
566  tmp1 = zero
567 *
568  DO 40 j = ibegin, iend - 1
569  tmp2 = abs( e( j ) )
570  gu = max( gu, d( j )+tmp1+tmp2 )
571  gl = min( gl, d( j )-tmp1-tmp2 )
572  tmp1 = tmp2
573  40 CONTINUE
574 *
575  gu = max( gu, d( iend )+tmp1 )
576  gl = min( gl, d( iend )-tmp1 )
577  bnorm = max( abs( gl ), abs( gu ) )
578  gl = gl - fudge*bnorm*ulp*in - fudge*pivmin
579  gu = gu + fudge*bnorm*ulp*in + fudge*pivmin
580 *
581 * Compute ATOLI for the current submatrix
582 *
583  IF( abstol.LE.zero ) THEN
584  atoli = ulp*max( abs( gl ), abs( gu ) )
585  ELSE
586  atoli = abstol
587  END IF
588 *
589  IF( irange.GT.1 ) THEN
590  IF( gu.LT.wl ) THEN
591  nwl = nwl + in
592  nwu = nwu + in
593  GO TO 70
594  END IF
595  gl = max( gl, wl )
596  gu = min( gu, wu )
597  IF( gl.GE.gu )
598  $ GO TO 70
599  END IF
600 *
601 * Set Up Initial Interval
602 *
603  work( n+1 ) = gl
604  work( n+in+1 ) = gu
605  CALL slaebz( 1, 0, in, in, 1, nb, atoli, rtoli, pivmin,
606  $ d( ibegin ), e( ibegin ), work( ibegin ),
607  $ idumma, work( n+1 ), work( n+2*in+1 ), im,
608  $ iwork, w( m+1 ), iblock( m+1 ), iinfo )
609 *
610  nwl = nwl + iwork( 1 )
611  nwu = nwu + iwork( in+1 )
612  iwoff = m - iwork( 1 )
613 *
614 * Compute Eigenvalues
615 *
616  itmax = int( ( log( gu-gl+pivmin )-log( pivmin ) ) /
617  $ log( two ) ) + 2
618  CALL slaebz( 2, itmax, in, in, 1, nb, atoli, rtoli, pivmin,
619  $ d( ibegin ), e( ibegin ), work( ibegin ),
620  $ idumma, work( n+1 ), work( n+2*in+1 ), iout,
621  $ iwork, w( m+1 ), iblock( m+1 ), iinfo )
622 *
623 * Copy Eigenvalues Into W and IBLOCK
624 * Use -JB for block number for unconverged eigenvalues.
625 *
626  DO 60 j = 1, iout
627  tmp1 = half*( work( j+n )+work( j+in+n ) )
628 *
629 * Flag non-convergence.
630 *
631  IF( j.GT.iout-iinfo ) THEN
632  ncnvrg = .true.
633  ib = -jb
634  ELSE
635  ib = jb
636  END IF
637  DO 50 je = iwork( j ) + 1 + iwoff,
638  $ iwork( j+in ) + iwoff
639  w( je ) = tmp1
640  iblock( je ) = ib
641  50 CONTINUE
642  60 CONTINUE
643 *
644  m = m + im
645  END IF
646  70 CONTINUE
647 *
648 * If RANGE='I', then (WL,WU) contains eigenvalues NWL+1,...,NWU
649 * If NWL+1 < IL or NWU > IU, discard extra eigenvalues.
650 *
651  IF( irange.EQ.3 ) THEN
652  im = 0
653  idiscl = il - 1 - nwl
654  idiscu = nwu - iu
655 *
656  IF( idiscl.GT.0 .OR. idiscu.GT.0 ) THEN
657  DO 80 je = 1, m
658  IF( w( je ).LE.wlu .AND. idiscl.GT.0 ) THEN
659  idiscl = idiscl - 1
660  ELSE IF( w( je ).GE.wul .AND. idiscu.GT.0 ) THEN
661  idiscu = idiscu - 1
662  ELSE
663  im = im + 1
664  w( im ) = w( je )
665  iblock( im ) = iblock( je )
666  END IF
667  80 CONTINUE
668  m = im
669  END IF
670  IF( idiscl.GT.0 .OR. idiscu.GT.0 ) THEN
671 *
672 * Code to deal with effects of bad arithmetic:
673 * Some low eigenvalues to be discarded are not in (WL,WLU],
674 * or high eigenvalues to be discarded are not in (WUL,WU]
675 * so just kill off the smallest IDISCL/largest IDISCU
676 * eigenvalues, by simply finding the smallest/largest
677 * eigenvalue(s).
678 *
679 * (If N(w) is monotone non-decreasing, this should never
680 * happen.)
681 *
682  IF( idiscl.GT.0 ) THEN
683  wkill = wu
684  DO 100 jdisc = 1, idiscl
685  iw = 0
686  DO 90 je = 1, m
687  IF( iblock( je ).NE.0 .AND.
688  $ ( w( je ).LT.wkill .OR. iw.EQ.0 ) ) THEN
689  iw = je
690  wkill = w( je )
691  END IF
692  90 CONTINUE
693  iblock( iw ) = 0
694  100 CONTINUE
695  END IF
696  IF( idiscu.GT.0 ) THEN
697 *
698  wkill = wl
699  DO 120 jdisc = 1, idiscu
700  iw = 0
701  DO 110 je = 1, m
702  IF( iblock( je ).NE.0 .AND.
703  $ ( w( je ).GT.wkill .OR. iw.EQ.0 ) ) THEN
704  iw = je
705  wkill = w( je )
706  END IF
707  110 CONTINUE
708  iblock( iw ) = 0
709  120 CONTINUE
710  END IF
711  im = 0
712  DO 130 je = 1, m
713  IF( iblock( je ).NE.0 ) THEN
714  im = im + 1
715  w( im ) = w( je )
716  iblock( im ) = iblock( je )
717  END IF
718  130 CONTINUE
719  m = im
720  END IF
721  IF( idiscl.LT.0 .OR. idiscu.LT.0 ) THEN
722  toofew = .true.
723  END IF
724  END IF
725 *
726 * If ORDER='B', do nothing -- the eigenvalues are already sorted
727 * by block.
728 * If ORDER='E', sort the eigenvalues from smallest to largest
729 *
730  IF( iorder.EQ.1 .AND. nsplit.GT.1 ) THEN
731  DO 150 je = 1, m - 1
732  ie = 0
733  tmp1 = w( je )
734  DO 140 j = je + 1, m
735  IF( w( j ).LT.tmp1 ) THEN
736  ie = j
737  tmp1 = w( j )
738  END IF
739  140 CONTINUE
740 *
741  IF( ie.NE.0 ) THEN
742  itmp1 = iblock( ie )
743  w( ie ) = w( je )
744  iblock( ie ) = iblock( je )
745  w( je ) = tmp1
746  iblock( je ) = itmp1
747  END IF
748  150 CONTINUE
749  END IF
750 *
751  info = 0
752  IF( ncnvrg )
753  $ info = info + 1
754  IF( toofew )
755  $ info = info + 2
756  RETURN
757 *
758 * End of SSTEBZ
759 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
Definition: tstiee.f:83
subroutine slaebz(IJOB, NITMAX, N, MMAX, MINP, NBMIN, ABSTOL, RELTOL, PIVMIN, D, E, E2, NVAL, AB, C, MOUT, NAB, WORK, IWORK, INFO)
SLAEBZ computes the number of eigenvalues of a real symmetric tridiagonal matrix which are less than ...
Definition: slaebz.f:321

Here is the call graph for this function:

Here is the caller graph for this function: