---
name: "slarrb.f"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/slarrb.f"
---

# slarrb.f(3)

## NAME

SRC/slarrb.f

## SYNOPSIS

### Functions/Subroutines

subroutine **slarrb** (n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info)\
 **SLARRB** provides limited bisection to locate eigenvalues for more accuracy.

## Function/Subroutine Documentation

### subroutine slarrb (integer n, real, dimension( \* ) d, real, dimension( \* ) lld, integer ifirst, integer ilast, real rtol1, real rtol2, integer offset, real, dimension( \* ) w, real, dimension( \* ) wgap, real, dimension( \* ) werr, real, dimension( \* ) work, integer, dimension( \* ) iwork, real pivmin, real spdiam, integer twist, integer info)

**SLARRB** provides limited bisection to locate eigenvalues for more accuracy.

**Purpose:**

```
!>
!> Given the relatively robust representation(RRR) L D L^T, SLARRB
!> does  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.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>          The order of the matrix.
!>
```

*D*

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

*LLD*

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

*IFIRST*

```
!>          IFIRST is INTEGER
!>          The index of the first eigenvalue to be computed.
!>
```

*ILAST*

```
!>          ILAST is INTEGER
!>          The index of the last eigenvalue to be computed.
!>
```

*RTOL1*

```
!>          RTOL1 is REAL
!>
```

*RTOL2*

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

*OFFSET*

```
!>          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*

```
!>          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 through
!>          ILAST.
!>          On output, these estimates are refined.
!>
```

*WGAP*

```
!>          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 = ILAST
!>          then WGAP(IFIRST-OFFSET) must be set to ZERO.
!>          On output, these gaps are refined.
!>
```

*WERR*

```
!>          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*

```
!>          WORK is REAL array, dimension (2*N)
!>          Workspace.
!>
```

*IWORK*

```
!>          IWORK is INTEGER array, dimension (2*N)
!>          Workspace.
!>
```

*PIVMIN*

```
!>          PIVMIN is REAL
!>          The minimum pivot in the Sturm sequence.
!>
```

*SPDIAM*

```
!>          SPDIAM is REAL
!>          The spectral diameter of the matrix.
!>
```

*TWIST*

```
!>          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*

```
!>          INFO is INTEGER
!>          Error flag.
!>
```

**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 **193** of file **slarrb.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.