dsterf.f

Go to the documentation of this file.

      SUBROUTINE dsterf( N, D, E, INFO )
*
*  -- LAPACK routine (version 3.0) --
*     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
*     Courant Institute, Argonne National Lab, and Rice University
*     June 30, 1999
*
*     .. Scalar Arguments ..
      INTEGER            INFO, N
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   D( * ), E( * )
*     ..
*
*  Purpose
*  =======
*
*  DSTERF computes all eigenvalues of a symmetric tridiagonal matrix
*  using the Pal-Walker-Kahan variant of the QL or QR algorithm.
*
*  Arguments
*  =========
*
*  N       (input) INTEGER
*          The order of the matrix.  N >= 0.
*
*  D       (input/output) DOUBLE PRECISION array, dimension (N)
*          On entry, the n diagonal elements of the tridiagonal matrix.
*          On exit, if INFO = 0, the eigenvalues in ascending order.
*
*  E       (input/output) DOUBLE PRECISION array, dimension (N-1)
*          On entry, the (n-1) subdiagonal elements of the tridiagonal
*          matrix.
*          On exit, E has been destroyed.
*
*  INFO    (output) INTEGER
*          = 0:  successful exit
*          < 0:  if INFO = -i, the i-th argument had an illegal value
*          > 0:  the algorithm failed to find all of the eigenvalues in
*                a total of 30*N iterations; if INFO = i, then i
*                elements of E have not converged to zero.
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ZERO, ONE, TWO, THREE
      parameter( zero = 0.0d0, one = 1.0d0, two = 2.0d0,
     $                   three = 3.0d0 )
      INTEGER            MAXIT
      parameter( maxit = 30 )
*     ..
*     .. Local Scalars ..
      INTEGER            I, ISCALE, JTOT, L, L1, LEND, LENDSV, LSV, M,
     $                   NMAXIT
      DOUBLE PRECISION   ALPHA, ANORM, BB, C, EPS, EPS2, GAMMA, OLDC,
     $                   OLDGAM, P, R, RT1, RT2, RTE, S, SAFMAX, SAFMIN,
     $                   SIGMA, SSFMAX, SSFMIN
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH, DLANST, DLAPY2
      EXTERNAL           dlamch, dlanst, dlapy2
*     ..
*     .. External Subroutines ..
      EXTERNAL           dlae2, dlascl, dlasrt, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, sign, sqrt
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
*
*     Quick return if possible
*
      IF( n.LT.0 ) THEN
         info = -1
         CALL xerbla( 'DSTERF', -info )
         RETURN
      END IF
      IF( n.LE.1 )
     $   RETURN
*
*     Determine the unit roundoff for this environment.
*
      eps = dlamch( 'E' )
      eps2 = eps**2
      safmin = dlamch( 'S' )
      safmax = one / safmin
      ssfmax = sqrt( safmax ) / three
      ssfmin = sqrt( safmin ) / eps2
*
*     Compute the eigenvalues of the tridiagonal matrix.
*
      nmaxit = n*maxit
      sigma = zero
      jtot = 0
*
*     Determine where the matrix splits and choose QL or QR iteration
*     for each block, according to whether top or bottom diagonal
*     element is smaller.
*
      l1 = 1
*
   10 CONTINUE
      IF( l1.GT.n )
     $   GO TO 170
      IF( l1.GT.1 )
     $   e( l1-1 ) = zero
      DO 20 m = l1, n - 1
         IF( abs( e( m ) ).LE.( sqrt( abs( d( m ) ) )*sqrt( abs( d( m+
     $       1 ) ) ) )*eps ) THEN
            e( m ) = zero
            GO TO 30
         END IF
   20 CONTINUE
      m = n
*
   30 CONTINUE
      l = l1
      lsv = l
      lend = m
      lendsv = lend
      l1 = m + 1
      IF( lend.EQ.l )
     $   GO TO 10
*
*     Scale submatrix in rows and columns L to LEND
*
      anorm = dlanst( 'I', lend-l+1, d( l ), e( l ) )
      iscale = 0
      IF( anorm.GT.ssfmax ) THEN
         iscale = 1
         CALL dlascl( 'G', 0, 0, anorm, ssfmax, lend-l+1, 1, d( l ), n,
     $                info )
         CALL dlascl( 'G', 0, 0, anorm, ssfmax, lend-l, 1, e( l ), n,
     $                info )
      ELSE IF( anorm.LT.ssfmin ) THEN
         iscale = 2
         CALL dlascl( 'G', 0, 0, anorm, ssfmin, lend-l+1, 1, d( l ), n,
     $                info )
         CALL dlascl( 'G', 0, 0, anorm, ssfmin, lend-l, 1, e( l ), n,
     $                info )
      END IF
*
      DO 40 i = l, lend - 1
         e( i ) = e( i )**2
   40 CONTINUE
*
*     Choose between QL and QR iteration
*
      IF( abs( d( lend ) ).LT.abs( d( l ) ) ) THEN
         lend = lsv
         l = lendsv
      END IF
*
      IF( lend.GE.l ) THEN
*
*        QL Iteration
*
*        Look for small subdiagonal element.
*
   50    CONTINUE
         IF( l.NE.lend ) THEN
            DO 60 m = l, lend - 1
               IF( abs( e( m ) ).LE.eps2*abs( d( m )*d( m+1 ) ) )
     $            GO TO 70
   60       CONTINUE
         END IF
         m = lend
*
   70    CONTINUE
         IF( m.LT.lend )
     $      e( m ) = zero
         p = d( l )
         IF( m.EQ.l )
     $      GO TO 90
*
*        If remaining matrix is 2 by 2, use DLAE2 to compute its
*        eigenvalues.
*
         IF( m.EQ.l+1 ) THEN
            rte = sqrt( e( l ) )
            CALL dlae2( d( l ), rte, d( l+1 ), rt1, rt2 )
            d( l ) = rt1
            d( l+1 ) = rt2
            e( l ) = zero
            l = l + 2
            IF( l.LE.lend )
     $         GO TO 50
            GO TO 150
         END IF
*
         IF( jtot.EQ.nmaxit )
     $      GO TO 150
         jtot = jtot + 1
*
*        Form shift.
*
         rte = sqrt( e( l ) )
         sigma = ( d( l+1 )-p ) / ( two*rte )
         r = dlapy2( sigma, one )
         sigma = p - ( rte / ( sigma+sign( r, sigma ) ) )
*
         c = one
         s = zero
         gamma = d( m ) - sigma
         p = gamma*gamma
*
*        Inner loop
*
         DO 80 i = m - 1, l, -1
            bb = e( i )
            r = p + bb
            IF( i.NE.m-1 )
     $         e( i+1 ) = s*r
            oldc = c
            c = p / r
            s = bb / r
            oldgam = gamma
            alpha = d( i )
            gamma = c*( alpha-sigma ) - s*oldgam
            d( i+1 ) = oldgam + ( alpha-gamma )
            IF( c.NE.zero ) THEN
               p = ( gamma*gamma ) / c
            ELSE
               p = oldc*bb
            END IF
   80    CONTINUE
*
         e( l ) = s*p
         d( l ) = sigma + gamma
         GO TO 50
*
*        Eigenvalue found.
*
   90    CONTINUE
         d( l ) = p
*
         l = l + 1
         IF( l.LE.lend )
     $      GO TO 50
         GO TO 150
*
      ELSE
*
*        QR Iteration
*
*        Look for small superdiagonal element.
*
  100    CONTINUE
         DO 110 m = l, lend + 1, -1
            IF( abs( e( m-1 ) ).LE.eps2*abs( d( m )*d( m-1 ) ) )
     $         GO TO 120
  110    CONTINUE
         m = lend
*
  120    CONTINUE
         IF( m.GT.lend )
     $      e( m-1 ) = zero
         p = d( l )
         IF( m.EQ.l )
     $      GO TO 140
*
*        If remaining matrix is 2 by 2, use DLAE2 to compute its
*        eigenvalues.
*
         IF( m.EQ.l-1 ) THEN
            rte = sqrt( e( l-1 ) )
            CALL dlae2( d( l ), rte, d( l-1 ), rt1, rt2 )
            d( l ) = rt1
            d( l-1 ) = rt2
            e( l-1 ) = zero
            l = l - 2
            IF( l.GE.lend )
     $         GO TO 100
            GO TO 150
         END IF
*
         IF( jtot.EQ.nmaxit )
     $      GO TO 150
         jtot = jtot + 1
*
*        Form shift.
*
         rte = sqrt( e( l-1 ) )
         sigma = ( d( l-1 )-p ) / ( two*rte )
         r = dlapy2( sigma, one )
         sigma = p - ( rte / ( sigma+sign( r, sigma ) ) )
*
         c = one
         s = zero
         gamma = d( m ) - sigma
         p = gamma*gamma
*
*        Inner loop
*
         DO 130 i = m, l - 1
            bb = e( i )
            r = p + bb
            IF( i.NE.m )
     $         e( i-1 ) = s*r
            oldc = c
            c = p / r
            s = bb / r
            oldgam = gamma
            alpha = d( i+1 )
            gamma = c*( alpha-sigma ) - s*oldgam
            d( i ) = oldgam + ( alpha-gamma )
            IF( c.NE.zero ) THEN
               p = ( gamma*gamma ) / c
            ELSE
               p = oldc*bb
            END IF
  130    CONTINUE
*
         e( l-1 ) = s*p
         d( l ) = sigma + gamma
         GO TO 100
*
*        Eigenvalue found.
*
  140    CONTINUE
         d( l ) = p
*
         l = l - 1
         IF( l.GE.lend )
     $      GO TO 100
         GO TO 150
*
      END IF
*
*     Undo scaling if necessary
*
  150 CONTINUE
      IF( iscale.EQ.1 )
     $   CALL dlascl( 'G', 0, 0, ssfmax, anorm, lendsv-lsv+1, 1,
     $                d( lsv ), n, info )
      IF( iscale.EQ.2 )
     $   CALL dlascl( 'G', 0, 0, ssfmin, anorm, lendsv-lsv+1, 1,
     $                d( lsv ), n, info )
*
*     Check for no convergence to an eigenvalue after a total
*     of N*MAXIT iterations.
*
      IF( jtot.LT.nmaxit )
     $   GO TO 10
      DO 160 i = 1, n - 1
         IF( e( i ).NE.zero )
     $      info = info + 1
  160 CONTINUE
      GO TO 180
*
*     Sort eigenvalues in increasing order.
*
  170 CONTINUE
      CALL dlasrt( 'I', n, d, info )
*
  180 CONTINUE
      RETURN
*
*     End of DSTERF
*
      END