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


SYNOPSIS

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

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

           DOUBLE         PRECISION RHO

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

           DOUBLE         PRECISION D(  *  ),  GIVNUM(  2,  *  ),
                          QSTORE( * ), RWORK( * )

           COMPLEX*16     Q( LDQ, * ), WORK( * )


PURPOSE

       ZLAED7  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  or banded Hermitian matrix that has been reduced to
       tridiagonal form.

         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 DLAED2.

             eigenvalues.  This  is  done by finding the roots of
       the secular
             equation  via  the  routine  DLAED4  (as  called  by
       SLAED3).
             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

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

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

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

       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) DOUBLE PRECISION array, dimension
              (N)
              On entry, the eigenvalues of  the  rank-1-perturbed
              matrix.   On  exit, the eigenvalues of the repaired
              matrix.

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

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

       RHO    (input) DOUBLE PRECISION
              Contains the subdiagonal element used to create the
              rank-1 modification.

       INDXQ  (output) INTEGER array, dimension (N)
              This contains the permutation  which  will  reinte­
              grate  the  subproblem just solved back into sorted
              order, ie. D( INDXQ( I =  1,  N  )  )  will  be  in
              ascending order.

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

       RWORK  (workspace) DOUBLE PRECISION array,
              dimension (3*N+2*QSIZ*N)

       WORK   (workspace) COMPLEX*16 array, dimension (QSIZ*N)

              QSTORE   (input/output)   DOUBLE  PRECISION  array,
              dimension (N**2+1) Stores eigenvectors of submatri­
              ces  encountered  during divide and conquer, packed
              together. QPTR points to beginning of the submatri­
              ces.

       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.

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

       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


Man(1) output converted with man2html