Loading...
Searching...
No Matches

## slarrv()

subroutine slarrv | ( | integer | n,
|  | real | vl,
|  | real | vu,
|  | real, dimension( * ) | d,
|  | real, dimension( * ) | l,
|  | real | pivmin,
|  | integer, dimension( * ) | isplit,
|  | integer | m,
|  | integer | dol,
|  | integer | dou,
|  | real | minrgp,
|  | real | rtol1,
|  | real | rtol2,
|  | real, dimension( * ) | w,
|  | real, dimension( * ) | werr,
|  | real, dimension( * ) | wgap,
|  | integer, dimension( * ) | iblock,
|  | integer, dimension( * ) | indexw,
|  | real, dimension( * ) | gers,
|  | real, dimension( ldz, * ) | z,
|  | integer | ldz,
|  | integer, dimension( * ) | isuppz,
|  | real, dimension( * ) | work,
|  | integer, dimension( * ) | iwork,
|  | integer | info )

SLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and the eigenvalues of L D LT.

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

Purpose:

      !>
      !> SLARRV computes the eigenvectors of the tridiagonal matrix
      !> T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.
      !> The input eigenvalues should have been computed by SLARRE.
      !>

Parameters

  [in]

  N

      !>          N is INTEGER
      !>          The order of the matrix.  N >= 0.
      !>

  [in]

  VL

      !>          VL is REAL
      !>          Lower bound of the interval that contains the desired
      !>          eigenvalues. VL < VU. Needed to compute gaps on the left or right
      !>          end of the extremal eigenvalues in the desired RANGE.
      !>

  [in]

  VU

      !>          VU is REAL
      !>          Upper bound of the interval that contains the desired
      !>          eigenvalues. VL < VU.
      !>          Note: VU is currently not used by this implementation of SLARRV, VU is
      !>          passed to SLARRV because it could be used compute gaps on the right end
      !>          of the extremal eigenvalues. However, with not much initial accuracy in
      !>          LAMBDA and VU, the formula can lead to an overestimation of the right gap
      !>          and thus to inadequately early RQI 'convergence'. This is currently
      !>          prevented this by forcing a small right gap. And so it turns out that VU
      !>          is currently not used by this implementation of SLARRV.
      !>

  [in,out]

  D

      !>          D is REAL array, dimension (N)
      !>          On entry, the N diagonal elements of the diagonal matrix D.
      !>          On exit, D may be overwritten.
      !>

  [in,out]

  L

      !>          L is REAL array, dimension (N)
      !>          On entry, the (N-1) subdiagonal elements of the unit
      !>          bidiagonal matrix L are in elements 1 to N-1 of L
      !>          (if the matrix is not split.) At the end of each block
      !>          is stored the corresponding shift as given by SLARRE.
      !>          On exit, L is overwritten.
      !>

  [in]

  PIVMIN

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

  [in]

  ISPLIT

      !>          ISPLIT is 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.
      !>

  [in]

  M

      !>          M is INTEGER
      !>          The total number of input eigenvalues.  0 <= M <= N.
      !>

  [in]

  DOL

      !>          DOL is INTEGER
      !>

  [in]

  DOU

      !>          DOU is INTEGER
      !>          If the user wants to compute only selected eigenvectors from all
      !>          the eigenvalues supplied, he can specify an index range DOL:DOU.
      !>          Or else the setting DOL=1, DOU=M should be applied.
      !>          Note that DOL and DOU refer to the order in which the eigenvalues
      !>          are stored in W.
      !>          If the user wants to compute only selected eigenpairs, then
      !>          the columns DOL-1 to DOU+1 of the eigenvector space Z contain the
      !>          computed eigenvectors. All other columns of Z are set to zero.
      !>

  [in]

  MINRGP

      !>          MINRGP is REAL
      !>

  [in]

  RTOL1

      !>          RTOL1 is REAL
      !>

  [in]

  RTOL2

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

  [in,out]

  W

      !>          W is REAL array, dimension (N)
      !>          The first M elements of W contain the APPROXIMATE eigenvalues for
      !>          which eigenvectors are to be computed.  The eigenvalues
      !>          should be grouped by split-off block and ordered from
      !>          smallest to largest within the block ( The output array
      !>          W from SLARRE is expected here ). Furthermore, they are with
      !>          respect to the shift of the corresponding root representation
      !>          for their block. On exit, W holds the eigenvalues of the
      !>          UNshifted matrix.
      !>

  [in,out]

  WERR

      !>          WERR is REAL array, dimension (N)
      !>          The first M elements contain the semiwidth of the uncertainty
      !>          interval of the corresponding eigenvalue in W
      !>

  [in,out]

  WGAP

      !>          WGAP is REAL array, dimension (N)
      !>          The separation from the right neighbor eigenvalue in W.
      !>

  [in]

  IBLOCK

      !>          IBLOCK is 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.
      !>

  [in]

  INDEXW

      !>          INDEXW is 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 the second block.
      !>

  [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)). The Gerschgorin intervals should
      !>          be computed from the original UNshifted matrix.
      !>

  [out]

  Z

      !>          Z is REAL array, dimension (LDZ, max(1,M) )
      !>          If INFO = 0, the first M columns of Z contain the
      !>          orthonormal eigenvectors of the matrix T
      !>          corresponding to the input eigenvalues, with the i-th
      !>          column of Z holding the eigenvector associated with W(i).
      !>          Note: the user must ensure that at least max(1,M) columns are
      !>          supplied in the array Z.
      !>

  [in]

  LDZ

      !>          LDZ is INTEGER
      !>          The leading dimension of the array Z.  LDZ >= 1, and if
      !>          JOBZ = 'V', LDZ >= max(1,N).
      !>

  [out]

  ISUPPZ

      !>          ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )
      !>          The support of the eigenvectors in Z, i.e., the indices
      !>          indicating the nonzero elements in Z. The I-th eigenvector
      !>          is nonzero only in elements ISUPPZ( 2*I-1 ) through
      !>          ISUPPZ( 2*I ).
      !>

  [out]

  WORK

      !>          WORK is REAL array, dimension (12*N)
      !>

  [out]

  IWORK

      !>          IWORK is INTEGER array, dimension (7*N)
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>          = 0:  successful exit
      !>
      !>          > 0:  A problem occurred in SLARRV.
      !>          < 0:  One of the called subroutines signaled an internal problem.
      !>                Needs inspection of the corresponding parameter IINFO
      !>                for further information.
      !>
      !>          =-1:  Problem in SLARRB when refining a child's eigenvalues.
      !>          =-2:  Problem in SLARRF when computing the RRR of a child.
      !>                When a child is inside a tight cluster, it can be difficult
      !>                to find an RRR. A partial remedy from the user's point of
      !>                view is to make the parameter MINRGP smaller and recompile.
      !>                However, as the orthogonality of the computed vectors is
      !>                proportional to 1/MINRGP, the user should be aware that
      !>                he might be trading in precision when he decreases MINRGP.
      !>          =-3:  Problem in SLARRB when refining a single eigenvalue
      !>                after the Rayleigh correction was rejected.
      !>          = 5:  The Rayleigh Quotient Iteration failed to converge to
      !>                full accuracy in MAXITR steps.
      !>

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