[ новости /+++ | форум | теги | ]

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

SYNOPSIS
     SUBROUTINE CLAED7( 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

     REAL RHO

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

     REAL D( * ), GIVNUM( 2, * ), QSTORE( * ), RWORK( * )

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



     #include <sunperf.h>

     void claed7(int n, int cutpnt,  int  qsiz,  int  tlvls,  int
               curlvl, int curpbm, float *d, complex *q, int ldq,
               float srho, int *indxq, float *qstore, int  *qptr,
               int  *prmptr, int *perm, int *givptr, int *givcol,
               float *givnum, int *info);

PURPOSE
     CLAED7 computes the updated eigensystem of a diagonal matrix
     after modification by a rank-one symmetric matrix. This rou-
     tine 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  prob-
     lem  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 SLAED2.

     The second stage consists of calculating the updated  eigen-
     values.  This  is  done  by finding the roots of the secular
     equation via the routine SLAED4 (as called by SLAED3).  This
     routine  also  calculates  the  eigenvectors  of the current
     problem.

     The final stage consists of computing the updated  eigenvec-
     tors  directly using the updated eigenvalues.  The eigenvec-
     tors 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) 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) COMPLEX array, dimension (LDQ,N)
               On entry, the eigenvectors of the rank-1-perturbed
               matrix.  On exit, the eigenvectors of the repaired
               tridiagonal matrix.

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

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

     INDXQ     (output) INTEGER array, dimension (N)
               This contains the  permutation  which  will  rein-
               tegrate  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) REAL array,
               dimension (3*N+2*QSIZ*N)

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

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

     QPTR      (input/output) INTEGER array, dimension (N+2)
               List of indices pointing to  beginning  of  subma-
               trices  stored in QSTORE. The submatrices are num-
               bered starting at the bottom left  of  the  divide
               and conquer 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 problem.

     PERM      (input) INTEGER array, dimension (N lg N)
               Contains  the  permutations  (from  deflation  and
               sorting) 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.

     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

Партнёры:

Хостинг: