slarrr()

subroutine slarrr	(	integer	n,
		real, dimension( * )	d,
		real, dimension( * )	e,
		integer	info
	)

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

Download SLARRR + 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 REAL array, dimension (N) The N diagonal elements of the tridiagonal matrix T.
[in,out]	E	E is REAL 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 93 of file slarrr.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 ..
      REAL               D( * ), E( * )
*     ..
*
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               ZERO, RELCOND
      parameter( zero = 0.0e0,
     $                     relcond = 0.999e0 )
*     ..
*     .. Local Scalars ..
      INTEGER            I
      LOGICAL            YESREL
      REAL               EPS, SAFMIN, SMLNUM, RMIN, TMP, TMP2,
     $          OFFDIG, OFFDIG2
 
*     ..
*     .. External Functions ..
      REAL               SLAMCH
      EXTERNAL           slamch
*     ..
*     .. 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 = slamch( 'Safe minimum' )
      eps = slamch( '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 SLARRR
*

Here is the caller graph for this function: