SLAED7  -  compute  the  updated eigensystem of a diagonal
       matrix after modification by a rank-one symmetric matrix


SYNOPSIS

       SUBROUTINE SLAED7( ICOMPQ, N, QSIZ, TLVLS, CURLVL, CURPBM,
                          D,  Q, LDQ, INDXQ, RHO, CUTPNT, QSTORE,
                          QPTR,  PRMPTR,  PERM,  GIVPTR,  GIVCOL,
                          GIVNUM, WORK, IWORK, INFO )

           INTEGER        CURLVL,  CURPBM,  CUTPNT, ICOMPQ, INFO,
                          LDQ, N, QSIZ, TLVLS

           REAL           RHO

           INTEGER        GIVCOL( 2, * ), GIVPTR( * ),  INDXQ(  *
                          ),  IWORK( * ), PERM( * ), PRMPTR( * ),
                          QPTR( * )

           REAL           D( * ), GIVNUM( 2, * ), Q(  LDQ,  *  ),
                          QSTORE( * ), WORK( * )


PURPOSE

       SLAED7  computes  the  updated  eigensystem  of a diagonal
       matrix after modification by a rank-one symmetric  matrix.
       This  routine  is  used  only  for  the eigenproblem which
       requires all eigenvalues and optionally eigenvectors of  a
       dense  symmetric matrix that has been reduced to tridiago­
       nal form.  SLAED1 handles the case in which all  eigenval­
       ues and eigenvectors of a symmetric tridiagonal matrix are
       desired.

         T = Q(in) ( D(in) + RHO *  Z*Z'  )  Q'(in)  =  Q(out)  *
       D(out) * Q'(out)

          where  Z  = Q'u, u is a vector of length N with ones in
       the
          CUTPNT and CUTPNT + 1 th elements and zeros  elsewhere.

          The  eigenvectors  of the original matrix are stored in
       Q, and the
          eigenvalues are in D.  The algorithm consists of  three
       stages:

             The  first  stage  consists of deflating the size of
       the problem
             when there are multiple eigenvalues or if there is a
       zero in
             the Z vector.  For each such occurence the dimension
       of the
             secular equation problem is reduced  by  one.   This
       stage is
             performed by the routine SLAED8.

             eigenvalues. This is done by finding  the  roots  of
       the secular
             equation  via  the  routine  SLAED4  (as  called  by
       SLAED9).
             This routine also calculates the eigenvectors of the
       current
             problem.

             The  final  stage  consists of computing the updated
       eigenvectors
             directly using the updated eigenvalues.  The  eigen­
       vectors for
             the  current  problem are multiplied with the eigen­
       vectors from
             the overall problem.


ARGUMENTS

       ICOMPQ  (input) INTEGER
               = 0:  Compute eigenvalues only.
               = 1:  Compute eigenvectors of original dense  sym­
               metric  matrix  also.   On  entry,  Q contains the
               orthogonal matrix  used  to  reduce  the  original
               matrix to tridiagonal form.

       N      (input) INTEGER
              The  dimension of the symmetric tridiagonal matrix.
              N >= 0.

       QSIZ   (input) INTEGER
              The dimension of  the  orthogonal  matrix  used  to
              reduce  the  full matrix to tridiagonal form.  QSIZ
              >= N if ICOMPQ = 1.

       TLVLS  (input) INTEGER
              The total number of merging levels in  the  overall
              divide and conquer tree.

              CURLVL  (input)  INTEGER  The  current level in the
              overall merge routine, 0 <= CURLVL <= TLVLS.

              CURPBM (input) INTEGER The current problem  in  the
              current  level in the overall merge routine (count­
              ing from upper left to lower right).

       D      (input/output) REAL array, dimension (N)
              On entry, the eigenvalues of  the  rank-1-perturbed
              matrix.   On  exit, the eigenvalues of the repaired
              matrix.

       Q      (input/output) REAL array, dimension (LDQ, N)
              On entry, the eigenvectors of the  rank-1-perturbed
              matrix.   On exit, the eigenvectors of the repaired


       LDQ    (input) INTEGER
              The leading dimension  of  the  array  Q.   LDQ  >=
              max(1,N).

       INDXQ  (output) INTEGER array, dimension (N)
              The permutation which will reintegrate the subprob­
              lem just solved back into sorted  order,  i.e.,  D(
              INDXQ( I = 1, N ) ) will be in ascending order.

       RHO    (input) REAL
              The  subdiagonal  element used to create the rank-1
              modification.

              CUTPNT (input) INTEGER Contains the location of the
              last   eigenvalue   in   the   leading  sub-matrix.
              min(1,N) <= CUTPNT <= N.

              QSTORE   (input/output)   REAL   array,   dimension
              (N**2+1) Stores eigenvectors of submatrices encoun­
              tered during divide and conquer,  packed  together.
              QPTR points to beginning of the submatrices.

       QPTR   (input/output) INTEGER array, dimension (N+2)
              List  of indices pointing to beginning of submatri­
              ces stored in QSTORE. The submatrices are  numbered
              starting  at the bottom left of the divide and con­
              quer tree, from left to right and bottom to top.

              PRMPTR (input) INTEGER array, dimension  (N  lg  N)
              Contains a list of pointers which indicate where in
              PERM a level's permutation is stored.   PRMPTR(i+1)
              -  PRMPTR(i)  indicates the size of the permutation
              and also the size of the full,  non-deflated  prob­
              lem.

       PERM   (input) INTEGER array, dimension (N lg N)
              Contains the permutations (from deflation and sort­
              ing) to be applied to each eigenblock.

              GIVPTR (input) INTEGER array, dimension  (N  lg  N)
              Contains a list of pointers which indicate where in
              GIVCOL  a  level's  Givens  rotations  are  stored.
              GIVPTR(i+1)  -  GIVPTR(i)  indicates  the number of
              Givens rotations.

              GIVCOL (input) INTEGER array, dimension (2, N lg N)
              Each pair of numbers indicates a pair of columns to
              take place in a Givens rotation.

              GIVNUM (input) REAL array, dimension (2,  N  lg  N)
              Each number indicates the S value to be used in the
              corresponding Givens rotation.


       IWORK  (workspace) INTEGER array, dimension (4*N)

       INFO   (output) INTEGER
              = 0:  successful exit.
              < 0:  if INFO = -i, the i-th argument had an  ille­
              gal value.
              > 0:  if INFO = 1, an eigenvalue did not converge


FURTHER DETAILS

       Based on contributions by
          Jeff  Rutter,  Computer Science Division, University of
       California
          at Berkeley, USA


Man(1) output converted with man2html