SLARRB(3)      LAPACK routine of NEC Numeric Library Collection      SLARRB(3)



NAME
       SLARRB

SYNOPSIS
       SUBROUTINE SLARRB (N, D, LLD, IFIRST, ILAST, RTOL1, RTOL2, OFFSET, W,
           WGAP, WERR, WORK, IWORK, PIVMIN, SPDIAM, TWIST, INFO)



PURPOSE
            Given the relatively robust representation(RRR) L D L^T, SLARRB
            does "limited" bisection to refine the eigenvalues of L D L^T,
            W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial
            guesses for these eigenvalues are input in W, the corresponding estimate
            of the error in these guesses and their gaps are input in WERR
            and WGAP, respectively. During bisection, intervals
            [left, right] are maintained by storing their mid-points and
            semi-widths in the arrays W and WERR respectively.




ARGUMENTS
           N         (input)
                     N is INTEGER
                     The order of the matrix.

           D         (input)
                     D is REAL array, dimension (N)
                     The N diagonal elements of the diagonal matrix D.

           LLD       (input)
                     LLD is REAL array, dimension (N-1)
                     The (N-1) elements L(i)*L(i)*D(i).

           IFIRST    (input)
                     IFIRST is INTEGER
                     The index of the first eigenvalue to be computed.

           ILAST     (input)
                     ILAST is INTEGER
                     The index of the last eigenvalue to be computed.

           RTOL1     (input)
                     RTOL1 is REAL

           RTOL2     (input)
                     RTOL2 is REAL
                     Tolerance for the convergence of the bisection intervals.
                     An interval [LEFT,RIGHT] has converged if
                     RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )
                     where GAP is the (estimated) distance to the nearest
                     eigenvalue.

           OFFSET    (input)
                     OFFSET is INTEGER
                     Offset for the arrays W, WGAP and WERR, i.e., the IFIRST-OFFSET
                     through ILAST-OFFSET elements of these arrays are to be used.

           W         (input/output)
                     W is REAL array, dimension (N)
                     On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are
                     estimates of the eigenvalues of L D L^T indexed IFIRST throug
                     ILAST.
                     On output, these estimates are refined.

           WGAP      (input/output)
                     WGAP is REAL array, dimension (N-1)
                     On input, the (estimated) gaps between consecutive
                     eigenvalues of L D L^T, i.e., WGAP(I-OFFSET) is the gap between
                     eigenvalues I and I+1. Note that if IFIRST.EQ.ILAST
                     then WGAP(IFIRST-OFFSET) must be set to ZERO.
                     On output, these gaps are refined.

           WERR      (input/output)
                     WERR is REAL array, dimension (N)
                     On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are
                     the errors in the estimates of the corresponding elements in W.
                     On output, these errors are refined.

           WORK      (output)
                     WORK is REAL array, dimension (2*N)
                     Workspace.

           IWORK     (output)
                     IWORK is INTEGER array, dimension (2*N)
                     Workspace.

           PIVMIN    (input)
                     PIVMIN is REAL
                     The minimum pivot in the Sturm sequence.

           SPDIAM    (input)
                     SPDIAM is REAL
                     The spectral diameter of the matrix.

           TWIST     (input)
                     TWIST is INTEGER
                     The twist index for the twisted factorization that is used
                     for the negcount.
                     TWIST = N: Compute negcount from L D L^T - LAMBDA I = L+ D+ L+^T
                     TWIST = 1: Compute negcount from L D L^T - LAMBDA I = U- D- U-^T
                     TWIST = R: Compute negcount from L D L^T - LAMBDA I = N(r) D(r) N(r)

           INFO      (output)
                     INFO is INTEGER
                     Error flag.



LAPACK routine                  31 October 2017                      SLARRB(3)