subroutine dlarrr	(	integer	N,
		double precision, dimension( * )	D,
		double precision, dimension( * )	E,
		integer	INFO
	)

DLARRR performs tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.

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

Purpose:

 Perform tests to decide whether the symmetric tridiagonal matrix T
 warrants expensive computations which guarantee high relative accuracy
 in the eigenvalues.

Parameters

[in]	N	N is INTEGER The order of the matrix. N > 0.
[in]	D	D is DOUBLE PRECISION array, dimension (N) The N diagonal elements of the tridiagonal matrix T.
[in,out]	E	E is DOUBLE PRECISION array, dimension (N) On entry, the first (N-1) entries contain the subdiagonal elements of the tridiagonal matrix T; E(N) is set to ZERO.
[out]	INFO	INFO is INTEGER INFO = 0(default) : the matrix warrants computations preserving relative accuracy. INFO = 1 : the matrix warrants computations guaranteeing only absolute accuracy.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

September 2012

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 96 of file dlarrr.f.

*
*  -- LAPACK auxiliary routine (version 3.4.2) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     September 2012
*
*     .. Scalar Arguments ..
      INTEGER            n, info
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   d( * ), e( * )
*     ..
*
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   zero, relcond
      parameter                ( zero = 0.0d0,
     $                     relcond = 0.999d0 )
*     ..
*     .. Local Scalars ..
      INTEGER            i
      LOGICAL            yesrel
      DOUBLE PRECISION   eps, safmin, smlnum, rmin, tmp, tmp2,
     $          offdig, offdig2

*     ..
*     .. External Functions ..
      DOUBLE PRECISION   dlamch
      EXTERNAL           dlamch
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs
*     ..
*     .. Executable Statements ..
*
*     As a default, do NOT go for relative-accuracy preserving computations.
      info = 1

      safmin = dlamch( 'Safe minimum' )
      eps = dlamch( 'Precision' )
      smlnum = safmin / eps
      rmin = sqrt( smlnum )

*     Tests for relative accuracy
*
*     Test for scaled diagonal dominance
*     Scale the diagonal entries to one and check whether the sum of the
*     off-diagonals is less than one
*
*     The sdd relative error bounds have a 1/(1- 2*x) factor in them,
*     x = max(OFFDIG + OFFDIG2), so when x is close to 1/2, no relative
*     accuracy is promised.  In the notation of the code fragment below,
*     1/(1 - (OFFDIG + OFFDIG2)) is the condition number.
*     We don't think it is worth going into "sdd mode" unless the relative
*     condition number is reasonable, not 1/macheps.
*     The threshold should be compatible with other thresholds used in the
*     code. We set  OFFDIG + OFFDIG2 <= .999 =: RELCOND, it corresponds
*     to losing at most 3 decimal digits: 1 / (1 - (OFFDIG + OFFDIG2)) <= 1000
*     instead of the current OFFDIG + OFFDIG2 < 1
*
      yesrel = .true.
      offdig = zero
      tmp = sqrt(abs(d(1)))
      IF (tmp.LT.rmin) yesrel = .false.
      IF(.NOT.yesrel) GOTO 11
      DO 10 i = 2, n
         tmp2 = sqrt(abs(d(i)))
         IF (tmp2.LT.rmin) yesrel = .false.
         IF(.NOT.yesrel) GOTO 11
         offdig2 = abs(e(i-1))/(tmp*tmp2)
         IF(offdig+offdig2.GE.relcond) yesrel = .false.
         IF(.NOT.yesrel) GOTO 11
         tmp = tmp2
         offdig = offdig2
 10   CONTINUE
 11   CONTINUE

      IF( yesrel ) THEN
         info = 0
         RETURN
      ELSE
      ENDIF
*

*
*     *** MORE TO BE IMPLEMENTED ***
*

*
*     Test if the lower bidiagonal matrix L from T = L D L^T
*     (zero shift facto) is well conditioned
*

*
*     Test if the upper bidiagonal matrix U from T = U D U^T
*     (zero shift facto) is well conditioned.
*     In this case, the matrix needs to be flipped and, at the end
*     of the eigenvector computation, the flip needs to be applied
*     to the computed eigenvectors (and the support)
*

*
      RETURN
*
*     END OF DLARRR
*

Here is the caller graph for this function: