dlarrr()

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.

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

*
*  -- LAPACK auxiliary routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. 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 ..
*
*     Quick return if possible
*
      IF( n.LE.0 ) THEN
         info = 0
         RETURN
      END IF
*
*     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: