slaed9()

subroutine slaed9	(	integer	k,
		integer	kstart,
		integer	kstop,
		integer	n,
		real, dimension( * )	d,
		real, dimension( ldq, * )	q,
		integer	ldq,
		real	rho,
		real, dimension( * )	dlambda,
		real, dimension( * )	w,
		real, dimension( lds, * )	s,
		integer	lds,
		integer	info )

SLAED9 used by SSTEDC. Finds the roots of the secular equation and updates the eigenvectors. Used when the original matrix is dense.

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

Purpose:

!>
!> SLAED9 finds the roots of the secular equation, as defined by the
!> values in D, Z, and RHO, between KSTART and KSTOP.  It makes the
!> appropriate calls to SLAED4 and then stores the new matrix of
!> eigenvectors for use in calculating the next level of Z vectors.
!> 

Parameters

[in]	K	!> K is INTEGER !> The number of terms in the rational function to be solved by !> SLAED4. K >= 0. !>
[in]	KSTART	!> KSTART is INTEGER !>
[in]	KSTOP	!> KSTOP is INTEGER !> The updated eigenvalues Lambda(I), KSTART <= I <= KSTOP !> are to be computed. 1 <= KSTART <= KSTOP <= K. !>
[in]	N	!> N is INTEGER !> The number of rows and columns in the Q matrix. !> N >= K (delation may result in N > K). !>
[out]	D	!> D is REAL array, dimension (N) !> D(I) contains the updated eigenvalues !> for KSTART <= I <= KSTOP. !>
[out]	Q	!> Q is REAL array, dimension (LDQ,N) !>
[in]	LDQ	!> LDQ is INTEGER !> The leading dimension of the array Q. LDQ >= max( 1, N ). !>
[in]	RHO	!> RHO is REAL !> The value of the parameter in the rank one update equation. !> RHO >= 0 required. !>
[in]	DLAMBDA	!> DLAMBDA is REAL array, dimension (K) !> The first K elements of this array contain the old roots !> of the deflated updating problem. These are the poles !> of the secular equation. !>
[in]	W	!> W is REAL array, dimension (K) !> The first K elements of this array contain the components !> of the deflation-adjusted updating vector. !>
[out]	S	!> S is REAL array, dimension (LDS, K) !> Will contain the eigenvectors of the repaired matrix which !> will be stored for subsequent Z vector calculation and !> multiplied by the previously accumulated eigenvectors !> to update the system. !>
[in]	LDS	!> LDS is INTEGER !> The leading dimension of S. LDS >= max( 1, K ). !>
[out]	INFO	!> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = 1, an eigenvalue did not converge !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

Definition at line 152 of file slaed9.f.

*
*  -- LAPACK computational routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            INFO, K, KSTART, KSTOP, LDQ, LDS, N
      REAL               RHO
*     ..
*     .. Array Arguments ..
      REAL               D( * ), DLAMBDA( * ), Q( LDQ, * ), S( LDS, * ),
     $                   W( * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      INTEGER            I, J
      REAL               TEMP
*     ..
*     .. External Functions ..
      REAL               SNRM2
      EXTERNAL           snrm2
*     ..
*     .. External Subroutines ..
      EXTERNAL           scopy, slaed4, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, sign, sqrt
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
*
      IF( k.LT.0 ) THEN
         info = -1
      ELSE IF( kstart.LT.1 .OR. kstart.GT.max( 1, k ) ) THEN
         info = -2
      ELSE IF( max( 1, kstop ).LT.kstart .OR. kstop.GT.max( 1, k ) )
     $          THEN
         info = -3
      ELSE IF( n.LT.k ) THEN
         info = -4
      ELSE IF( ldq.LT.max( 1, k ) ) THEN
         info = -7
      ELSE IF( lds.LT.max( 1, k ) ) THEN
         info = -12
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'SLAED9', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( k.EQ.0 )
     $   RETURN
*
      DO 20 j = kstart, kstop
         CALL slaed4( k, j, dlambda, w, q( 1, j ), rho, d( j ),
     $                info )
*
*        If the zero finder fails, the computation is terminated.
*
         IF( info.NE.0 )
     $      GO TO 120
   20 CONTINUE
*
      IF( k.EQ.1 .OR. k.EQ.2 ) THEN
         DO 40 i = 1, k
            DO 30 j = 1, k
               s( j, i ) = q( j, i )
   30       CONTINUE
   40    CONTINUE
         GO TO 120
      END IF
*
*     Compute updated W.
*
      CALL scopy( k, w, 1, s, 1 )
*
*     Initialize W(I) = Q(I,I)
*
      CALL scopy( k, q, ldq+1, w, 1 )
      DO 70 j = 1, k
         DO 50 i = 1, j - 1
            w( i ) = w( i )*( q( i, j )/( dlambda( i )-dlambda( j ) ) )
   50    CONTINUE
         DO 60 i = j + 1, k
            w( i ) = w( i )*( q( i, j )/( dlambda( i )-dlambda( j ) ) )
   60    CONTINUE
   70 CONTINUE
      DO 80 i = 1, k
         w( i ) = sign( sqrt( -w( i ) ), s( i, 1 ) )
   80 CONTINUE
*
*     Compute eigenvectors of the modified rank-1 modification.
*
      DO 110 j = 1, k
         DO 90 i = 1, k
            q( i, j ) = w( i ) / q( i, j )
   90    CONTINUE
         temp = snrm2( k, q( 1, j ), 1 )
         DO 100 i = 1, k
            s( i, j ) = q( i, j ) / temp
  100    CONTINUE
  110 CONTINUE
*
  120 CONTINUE
      RETURN
*
*     End of SLAED9
*

Here is the call graph for this function:

Here is the caller graph for this function: