slarrd()

subroutine slarrd	(	character	range,
		character	order,
		integer	n,
		real	vl,
		real	vu,
		integer	il,
		integer	iu,
		real, dimension( * )	gers,
		real	reltol,
		real, dimension( * )	d,
		real, dimension( * )	e,
		real, dimension( * )	e2,
		real	pivmin,
		integer	nsplit,
		integer, dimension( * )	isplit,
		integer	m,
		real, dimension( * )	w,
		real, dimension( * )	werr,
		real	wl,
		real	wu,
		integer, dimension( * )	iblock,
		integer, dimension( * )	indexw,
		real, dimension( * )	work,
		integer, dimension( * )	iwork,
		integer	info )

SLARRD computes the eigenvalues of a symmetric tridiagonal matrix to suitable accuracy.

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

Purpose:

!>
!> SLARRD computes the eigenvalues of a symmetric tridiagonal
!> matrix T to suitable accuracy. This is an auxiliary code to be
!> called from SSTEMR.
!> 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 , Report CS41, Computer Science Dept., Stanford
!> University, July 21, 1966.
!> 

Parameters

[in]	RANGE	!> RANGE is CHARACTER*1 !> = 'A': () all eigenvalues will be found. !> = 'V': () all eigenvalues in the half-open interval !> (VL, VU] will be found. !> = 'I': () the IL-th through IU-th eigenvalues (of the !> entire matrix) will be found. !>
[in]	ORDER	!> ORDER is CHARACTER*1 !> = 'B': () the eigenvalues will be grouped by !> split-off block (see IBLOCK, ISPLIT) and !> ordered from smallest to largest within !> the block. !> = 'E': () !> 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 REAL !> If RANGE='V', the lower bound 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]	VU	!> VU is REAL !> If RANGE='V', the upper bound 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 !> If RANGE='I', the index of the !> smallest eigenvalue 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]	IU	!> IU is INTEGER !> If RANGE='I', the index of the !> largest eigenvalue 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]	GERS	!> GERS is REAL array, dimension (2*N) !> The N Gerschgorin intervals (the i-th Gerschgorin interval !> is (GERS(2*i-1), GERS(2*i)). !>
[in]	RELTOL	!> RELTOL is REAL !> 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. !>
[in]	D	!> D is REAL array, dimension (N) !> The n diagonal elements of the tridiagonal matrix T. !>
[in]	E	!> E is REAL array, dimension (N-1) !> The (n-1) off-diagonal elements of the tridiagonal matrix T. !>
[in]	E2	!> E2 is REAL array, dimension (N-1) !> The (n-1) squared off-diagonal elements of the tridiagonal matrix T. !>
[in]	PIVMIN	!> PIVMIN is REAL !> The minimum pivot allowed in the Sturm sequence for T. !>
[in]	NSPLIT	!> NSPLIT is INTEGER !> The number of diagonal blocks in the matrix T. !> 1 <= NSPLIT <= N. !>
[in]	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]	M	!> M is INTEGER !> The actual number of eigenvalues found. 0 <= M <= N. !> (See also the description of INFO=2,3.) !>
[out]	W	!> W is REAL array, dimension (N) !> On exit, the first M elements of W will contain the !> eigenvalue approximations. SLARRD computes an interval !> I_j = (a_j, b_j] that includes eigenvalue j. The eigenvalue !> approximation is given as the interval midpoint !> W(j)= ( a_j + b_j)/2. The corresponding error is bounded by !> WERR(j) = abs( a_j - b_j)/2 !>
[out]	WERR	!> WERR is REAL array, dimension (N) !> The error bound on the corresponding eigenvalue approximation !> in W. !>
[out]	WL	!> WL is REAL !>
[out]	WU	!> WU is REAL !> The interval (WL, WU] contains all the wanted eigenvalues. !> If RANGE='V', then WL=VL and WU=VU. !> If RANGE='A', then WL and WU are the global Gerschgorin bounds !> on the spectrum. !> If RANGE='I', then WL and WU are computed by SLAEBZ from the !> index range specified. !>
[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. (SLARRD may use the remaining N-M elements as !> workspace.) !>
[out]	INDEXW	!> INDEXW is INTEGER array, dimension (N) !> The indices of the eigenvalues within each block (submatrix); !> for example, INDEXW(i)= j and IBLOCK(i)=k imply that the !> i-th eigenvalue W(i) is the j-th eigenvalue in block k. !>
[out]	WORK	!> WORK is REAL 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 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 , !> recompile, and try again. !>

Internal Parameters:

!>  FUDGE   REAL, default = 2
!>          A  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.
!> 

Contributors:

W. Kahan, University of California, Berkeley, USA
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

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.