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

Go to the source code of this file.

Functions/Subroutines

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

Function/Subroutine Documentation

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

DSTEBZ

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

Purpose:
 DSTEBZ 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 DOUBLE PRECISION
[in]VU
          VU is DOUBLE PRECISION

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

Here is the call graph for this function:

Here is the caller graph for this function: