dlarrk()

subroutine dlarrk	(	integer	N,
		integer	IW,
		double precision	GL,
		double precision	GU,
		double precision, dimension( * )	D,
		double precision, dimension( * )	E2,
		double precision	PIVMIN,
		double precision	RELTOL,
		double precision	W,
		double precision	WERR,
		integer	INFO
	)

DLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy.

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

Purpose:

 DLARRK computes one eigenvalue of a symmetric tridiagonal
 matrix T to suitable accuracy. This is an auxiliary code to be
 called from DSTEMR.

 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]	N	N is INTEGER The order of the tridiagonal matrix T. N >= 0.
[in]	IW	IW is INTEGER The index of the eigenvalues to be returned.
[in]	GL	GL is DOUBLE PRECISION
[in]	GU	GU is DOUBLE PRECISION An upper and a lower bound on the eigenvalue.
[in]	D	D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix T.
[in]	E2	E2 is DOUBLE PRECISION array, dimension (N-1) The (n-1) squared off-diagonal elements of the tridiagonal matrix T.
[in]	PIVMIN	PIVMIN is DOUBLE PRECISION The minimum pivot allowed in the Sturm sequence for T.
[in]	RELTOL	RELTOL is DOUBLE PRECISION The minimum relative width of an interval. When an interval is narrower than RELTOL times the larger (in magnitude) endpoint, then it is considered to be sufficiently small, i.e., converged. Note: this should always be at least radix*machine epsilon.
[out]	W	W is DOUBLE PRECISION
[out]	WERR	WERR is DOUBLE PRECISION The error bound on the corresponding eigenvalue approximation in W.
[out]	INFO	INFO is INTEGER = 0: Eigenvalue converged = -1: Eigenvalue did NOT converge

Internal Parameters:

  FUDGE   DOUBLE PRECISION, default = 2
          A "fudge factor" to widen the Gershgorin intervals.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

June 2017

Definition at line 147 of file dlarrk.f.

*
*  -- LAPACK auxiliary routine (version 3.7.1) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     June 2017
*
*     .. Scalar Arguments ..
      INTEGER   INFO, IW, N
      DOUBLE PRECISION    PIVMIN, RELTOL, GL, GU, W, WERR
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   D( * ), E2( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   FUDGE, HALF, TWO, ZERO
      parameter( half = 0.5d0, two = 2.0d0,
     $                     fudge = two, zero = 0.0d0 )
*     ..
*     .. Local Scalars ..
      INTEGER   I, IT, ITMAX, NEGCNT
      DOUBLE PRECISION   ATOLI, EPS, LEFT, MID, RIGHT, RTOLI, TMP1,
     $                   TMP2, TNORM
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH
      EXTERNAL   dlamch
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, int, log, max
*     ..
*     .. Executable Statements ..
*
*     Quick return if possible
*
      IF( n.LE.0 ) THEN
         info = 0
         RETURN
      END IF
*
*     Get machine constants
      eps = dlamch( 'P' )
 
      tnorm = max( abs( gl ), abs( gu ) )
      rtoli = reltol
      atoli = fudge*two*pivmin
 
      itmax = int( ( log( tnorm+pivmin )-log( pivmin ) ) /
     $           log( two ) ) + 2
 
      info = -1
 
      left = gl - fudge*tnorm*eps*n - fudge*two*pivmin
      right = gu + fudge*tnorm*eps*n + fudge*two*pivmin
      it = 0
 
 10   CONTINUE
*
*     Check if interval converged or maximum number of iterations reached
*
      tmp1 = abs( right - left )
      tmp2 = max( abs(right), abs(left) )
      IF( tmp1.LT.max( atoli, pivmin, rtoli*tmp2 ) ) THEN
         info = 0
         GOTO 30
      ENDIF
      IF(it.GT.itmax)
     $   GOTO 30
 
*
*     Count number of negative pivots for mid-point
*
      it = it + 1
      mid = half * (left + right)
      negcnt = 0
      tmp1 = d( 1 ) - mid
      IF( abs( tmp1 ).LT.pivmin )
     $   tmp1 = -pivmin
      IF( tmp1.LE.zero )
     $   negcnt = negcnt + 1
*
      DO 20 i = 2, n
         tmp1 = d( i ) - e2( i-1 ) / tmp1 - mid
         IF( abs( tmp1 ).LT.pivmin )
     $      tmp1 = -pivmin
         IF( tmp1.LE.zero )
     $      negcnt = negcnt + 1
 20   CONTINUE
 
      IF(negcnt.GE.iw) THEN
         right = mid
      ELSE
         left = mid
      ENDIF
      GOTO 10
 
 30   CONTINUE
*
*     Converged or maximum number of iterations reached
*
      w = half * (left + right)
      werr = half * abs( right - left )
 
      RETURN
*
*     End of DLARRK
*

Here is the caller graph for this function: