SLARRE2(3)    ScaLAPACK routine of NEC Numeric Library Collection   SLARRE2(3)



NAME
       SLARRE2  -  To  find  the desired eigenvalues of a given real symmetric
       tridiagonal matrix T, SLARRE2 sets, via  SLARRA,  "small"  off-diagonal
       elements to zero

SYNOPSIS
       SUBROUTINE SLARRE2( RANGE,  N,  VL, VU, IL, IU, D, E, E2, RTOL1, RTOL2,
                           SPLTOL, NSPLIT, ISPLIT, M, DOL, DOU, W, WERR, WGAP,
                           IBLOCK, INDEXW, GERS, PIVMIN, WORK, IWORK, INFO )

           CHARACTER       RANGE

           INTEGER         DOL, DOU, IL, INFO, IU, M, N, NSPLIT

           REAL            PIVMIN, RTOL1, RTOL2, SPLTOL, VL, VU

           INTEGER         IBLOCK( * ), ISPLIT( * ), IWORK( * ), INDEXW( * )

           REAL            D(  * ), E( * ), E2( * ), GERS( * ), W( * ),WERR( *
                           ), WGAP( * ), WORK( * )

PURPOSE
       To find the desired eigenvalues of a given real  symmetric  tridiagonal
       matrix  T,  SLARRE2  sets, via SLARRA, "small" off-diagonal elements to
       zero. For each block T_i, it finds
       (a) a suitable shift at one end of the block's spectrum,
       (b) the root RRR, T_i - sigma_i I = L_i D_i L_i^T, and
       (c) eigenvalues of each L_i D_i L_i^T.
       The representations and eigenvalues found are then returned to  SSTEGR2
       to compute the eigenvectors  T.

       SLARRE2  is  more  suitable  for parallel computation than the original
       LAPACK code for computing the root RRR and its eigenvalues.
       When computing eigenvalues in parallel and the input tridiagonal matrix
       splits  into blocks, SLARRE2 can skip over blocks which contain none of
       the eigenvalues from DOL to DOU for which the processor responsible. In
       extreme  cases  (such  as  large  matrices consisting of many blocks of
       small size, e.g. 2x2, the gain can be substantial.


ARGUMENTS
       RANGE   (input) CHARACTER
               = 'A': ("All")   all eigenvalues will be found.
               = 'V': ("Value") all eigenvalues in the half-open interval
                                (VL, VU] will be found.
               = 'I': ("Index") the IL-th through IU-th eigenvalues (of the
                                entire matrix) will be found.

       N       (input) INTEGER
               The order of the matrix. N > 0.

       VL      (input/output) REAL

       VU      (input/output) REAL
               If RANGE='V', the lower and upper bounds for the eigenvalues.
               Eigenvalues less than or equal to VL, or greater than VU,  will
               not be returned.  VL < VU.
               If  RANGE='I'  or  ='A', SLARRE2 computes bounds on the desired
               part of the spectrum.

       IL      (input) INTEGER

       IU      (input) INTEGER
               If RANGE='I', the indices (in ascending order) of the  smallest
               and largest eigenvalues to be returned.
               1 <= IL <= IU <= N.

       D       (input/output) REAL array, dimension (N)
               On  entry, the N diagonal elements of the tridiagonal matrix T.
               On exit, the N diagonal elements of the diagonal matrices  D_i.

       E       (input/output) REAL array, dimension (N)
               On  entry, the first (N-1) entries contain the subdiagonal ele-
               ments of the tridiagonal matrix T; E(N) need not be set.
               On exit, E contains the subdiagonal elements of the unit  bidi-
               agonal  matrices  L_i.  The entries E( ISPLIT( I ) ), 1 <= I <=
               NSPLIT, contain the base points sigma_i on output.

       E2      (input/output) REAL array, dimension (N)
               On entry, the first (N-1) entries contain the  SQUARES  of  the
               subdiagonal  elements  of  the tridiagonal matrix T; E2(N) need
               not be set.
               On exit, the entries E2( ISPLIT( I ) ), 1 <= I <= NSPLIT,  have
               been set to zero

       RTOL1   (input) REAL

       RTOL2   (input) REAL
               Parameters for bisection.
               An  interval  [LEFT,RIGHT]  has converged if RIGHT-LEFT.LT.MAX(
               RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )

       SPLTOL (input) REAL
               The threshold for splitting.

       NSPLIT  (output) INTEGER
               The number of blocks T splits into. 1 <= NSPLIT <= N.

       ISPLIT  (output) INTEGER array, dimension (N)
               The splitting points, at which T breaks up into blocks.
               The first block 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.

       M       (output) INTEGER
               The total number of eigenvalues (of all L_i D_i L_i^T) found.

       DOL     (input) INTEGER

       DOU     (input) INTEGER
               If the user wants to work on only a selected part of the repre-
               sentation tree, he can specify an index range DOL:DOU.
               Otherwise, the setting DOL=1, DOU=N should be applied.
               Note that DOL and DOU refer to the order in which the eigenval-
               ues are stored in W.

       W       (output) REAL array, dimension (N)
               The  first  M elements contain the eigenvalues. The eigenvalues
               of each of the blocks, L_i D_i L_i^T, are sorted  in  ascending
               order   (  SLARRE2  may  use  the  remaining  N-M  elements  as
               workspace).
               Note that immediately after  exiting  this  routine,  only  the
               eigenvalues  from  position  DOL:DOU  in W might be reliable on
               this processor when the eigenvalue computation is done in  par-
               allel.

       WERR    (output) REAL array, dimension (N)
               The error bound on the corresponding eigenvalue in W.
               Note  that  immediately  after  exiting  this routine, only the
               uncertainties from position DOL:DOU in WERR might  be  reliable
               on  this  processor  when the eigenvalue computation is done in
               parallel.

       WGAP    (output) REAL array, dimension (N)
               The separation from the right neighbor eigenvalue in W.
               The gap is only with respect to the  eigenvalues  of  the  same
               block as each block has its own representation tree.
               Exception:  at  the  right end of a block we store the left gap
               Note that immediately after exiting this routine, only the gaps
               from position DOL:DOU in WGAP might be reliable on this proces-
               sor when the eigenvalue computation is done in parallel.

       IBLOCK  (output) INTEGER array, dimension (N)
               The indices of the blocks  (submatrices)  associated  with  the
               corresponding  eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i)
               belongs to the first block from the top, =2 if W(i) belongs  to
               the second block, etc.

       INDEXW  (output) INTEGER array, dimension (N)
               The  indices  of the eigenvalues within each block (submatrix);
               for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the  i-th
               eigenvalue W(i) is the 10-th eigenvalue in block 2

       GERS    (output) REAL array, dimension (2*N)
               The  N  Gerschgorin intervals (the i-th Gerschgorin interval is
               (GERS(2*i-1), GERS(2*i)).

       PIVMIN  (output) REAL
               The minimum pivot in the sturm sequence for T.

       WORK    (workspace) REAL array, dimension (6*N)
               Workspace.

       IWORK   (workspace) INTEGER array, dimension (5*N)
               Workspace.

       INFO    (output) INTEGER
               = 0:  successful exit
               > 0:  A problem occured in SLARRE2.
               < 0:  One of the called subroutines signaled an internal
                     probrem. Needs inspection of the corresponding
                     parameter INFO for further information.

               =-1:  Problem in SLARRD.
               = 2:  No base representation could be found  in  MAXTRY  itera-
               tions.
                     Increasing MAXTRY and recompilation might be a remedy.
               =-3:  Problem in SLARRB when computing the refined root
                     representation for SLASQ2.
               =-4:  Problem in SLARRB when preforming bisection on the
                     desired part of the spectrum.
               =-5:  Problem in SLASQ2.
               =-6:  Problem in SLASQ2.



ScaLAPACK routine               31 October 2017                     SLARRE2(3)