slarrf2.f

Go to the documentation of this file.

      SUBROUTINE slarrf2( N, D, L, LD, CLSTRT, CLEND, 
     $                   CLMID1, CLMID2, W, WGAP, WERR, TRYMID,
     $                   SPDIAM, CLGAPL, CLGAPR, PIVMIN, SIGMA,
     $                   DPLUS, LPLUS, WORK, INFO )
*
*  -- ScaLAPACK computational routine (version 2.0) --
*     Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver
*     July 4, 2010
*
      IMPLICIT NONE
*
*     .. Scalar Arguments ..
      INTEGER            CLSTRT, CLEND, CLMID1, CLMID2, INFO, N
      REAL               CLGAPL, CLGAPR, PIVMIN, SIGMA, SPDIAM
      LOGICAL TRYMID
*     ..
*     .. Array Arguments ..
      REAL               D( * ), DPLUS( * ), L( * ), LD( * ), 
     $          LPLUS( * ), W( * ), WGAP( * ), WERR( * ), WORK( * )
*     ..
*
*  Purpose
*  =======
*
*  Given the initial representation L D L^T and its cluster of close
*  eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ...
*  W( CLEND ), SLARRF2 finds a new relatively robust representation
*  L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the
*  eigenvalues of L(+) D(+) L(+)^T is relatively isolated.
*
*  This is an enhanced version of SLARRF that also tries shifts in
*  the middle of the cluster, should there be a large gap, in order to
*  break large clusters into at least two pieces.
*
*  Arguments
*  =========
*
*  N       (input) INTEGER
*          The order of the matrix (subblock, if the matrix splitted).
*
*  D       (input) REAL             array, dimension (N)
*          The N diagonal elements of the diagonal matrix D.
*
*  L       (input) REAL             array, dimension (N-1)
*          The (N-1) subdiagonal elements of the unit bidiagonal
*          matrix L.
*
*  LD      (input) REAL             array, dimension (N-1)
*          The (N-1) elements L(i)*D(i).
*
*  CLSTRT  (input) INTEGER
*          The index of the first eigenvalue in the cluster.
*
*  CLEND   (input) INTEGER
*          The index of the last eigenvalue in the cluster.
*
*  CLMID1,2(input) INTEGER
*          The index of a middle eigenvalue pair with large gap
*
*  W       (input) REAL             array, dimension >=  (CLEND-CLSTRT+1)
*          The eigenvalue APPROXIMATIONS of L D L^T in ascending order.
*          W( CLSTRT ) through W( CLEND ) form the cluster of relatively
*          close eigenalues.
*
*  WGAP    (input/output) REAL             array, dimension >=  (CLEND-CLSTRT+1)
*          The separation from the right neighbor eigenvalue in W.
*
*  WERR    (input) REAL             array, dimension >=  (CLEND-CLSTRT+1)
*          WERR contain the semiwidth of the uncertainty
*          interval of the corresponding eigenvalue APPROXIMATION in W
*
*  SPDIAM (input) estimate of the spectral diameter obtained from the
*          Gerschgorin intervals
*
*  CLGAPL, CLGAPR (input) absolute gap on each end of the cluster.
*          Set by the calling routine to protect against shifts too close
*          to eigenvalues outside the cluster.
*
*  PIVMIN  (input) DOUBLE PRECISION
*          The minimum pivot allowed in the sturm sequence.
*
*  SIGMA   (output) REAL            
*          The shift used to form L(+) D(+) L(+)^T.
*
*  DPLUS   (output) REAL             array, dimension (N)
*          The N diagonal elements of the diagonal matrix D(+).
*
*  LPLUS   (output) REAL             array, dimension (N-1)
*          The first (N-1) elements of LPLUS contain the subdiagonal
*          elements of the unit bidiagonal matrix L(+).
*
*  WORK    (workspace) REAL             array, dimension (2*N)
*          Workspace.
*
*  Further Details
*  ===============
*
*  Based on contributions by
*     Beresford Parlett, University of California, Berkeley, USA
*     Jim Demmel, University of California, Berkeley, USA
*     Inderjit Dhillon, University of Texas, Austin, USA
*     Osni Marques, LBNL/NERSC, USA
*     Christof Voemel, University of California, Berkeley, USA
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               FOUR, MAXGROWTH1, MAXGROWTH2, ONE, QUART, TWO
      PARAMETER          ( ONE = 1.0e0, two = 2.0e0,
     $                     four = 4.0e0, quart = 0.25e0,
     $                     maxgrowth1 = 8.e0,
     $                     maxgrowth2 = 8.e0 )
*     ..
*     .. Local Scalars ..
      LOGICAL   DORRR1, NOFAIL, SAWNAN1, SAWNAN2, TRYRRR1
      INTEGER      BI,I,J,KTRY,KTRYMAX,SLEFT,SRIGHT,SMID,SHIFT
      PARAMETER   ( KTRYMAX = 1, smid =0, sleft = 1, sright = 2 )
 
*     DSTQDS loops will be blocked to detect NaNs earlier if they occur
      INTEGER BLKLEN
      PARAMETER ( BLKLEN = 512 )
 
 
      REAL               AVGAP, BESTSHIFT, CLWDTH, EPS, FACT, FAIL,
     $                   FAIL2, GROWTHBOUND, LDELTA, LDMAX, LEASTGROWTH,
     $                   LSIGMA, MAX1, MAX2, MINGAP, MSIGMA1, MSIGMA2,
     $                   oldp, prod, rdelta, rdmax, rrr1, rrr2, rsigma,
     $                   s, tmp, znm2
*     ..
*     .. External Functions ..
      LOGICAL SISNAN
      REAL               SLAMCH
      EXTERNAL           SISNAN, SLAMCH
*     ..
*     .. External Subroutines ..
      EXTERNAL           scopy
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs
*     ..
*     .. Executable Statements ..
*
      info = 0
      fact = real(2**ktrymax)
      eps = slamch( 'Precision' )
      shift = 0
      
*     Decide whether the code should accept the best among all 
*     representations despite large element growth or signal INFO=1
      nofail = .true.
*
 
*     Compute the average gap length of the cluster
      clwdth = abs(w(clend)-w(clstrt)) + werr(clend) + werr(clstrt)
      avgap = clwdth / real(clend-clstrt)
      mingap = min(clgapl, clgapr)
 
*     Initial values for shifts to both ends of cluster
      lsigma = min(w( clstrt ),w( clend )) - werr( clstrt )
      rsigma = max(w( clstrt ),w( clend )) + werr( clend )
      msigma1 = w( clmid1 ) + werr( clmid1 )
      msigma2 = w( clmid2 ) - werr( clmid2 )
 
*     Use a small fudge to make sure that we really shift to the outside
      lsigma = lsigma - abs(lsigma)* two * eps
      rsigma = rsigma + abs(rsigma)* two * eps
 
*     Compute upper bounds for how much to back off the initial shifts
      ldmax = quart * mingap + two * pivmin
      rdmax = quart * mingap + two * pivmin
        
      ldelta = max(avgap,wgap( clstrt ))/fact
      rdelta = max(avgap,wgap( clend-1 ))/fact
*
*     Initialize the record of the best representation found
*
      s = slamch( 'S' )
      leastgrowth = one / s 
      fail = real(n-1)*mingap/(spdiam*eps)
      fail2 = real(n-1)*mingap/(spdiam*sqrt(eps))
      growthbound = maxgrowth1*spdiam
 
*
*     Set default best shift
*
      bestshift = lsigma
 
 
      IF(.NOT.trymid) GOTO 4
*
*     Try shifts in the middle
*     
      shift = smid
 
      DO 3 j=1,2
         sawnan1 = .false.
         IF(j.EQ.1) THEN
*           Try left middle point
            sigma = msigma1
         ELSE
*           Try left middle point
            sigma = msigma2
         ENDIF   
 
         s = -sigma
         dplus( 1 ) = d( 1 ) + s
         max1 = abs( dplus( 1 ) )
         DO 2 bi = 1, n-1, blklen
            DO 1 i = bi, min( bi+blklen-1, n-1)
               lplus( i ) = ld( i ) / dplus( i )
               s = s*lplus( i )*l( i ) - sigma
               dplus( i+1 ) = d( i+1 ) + s
               max1 = max( max1,abs(dplus(i+1)) )
 1          CONTINUE
            sawnan1=sawnan1 .OR. sisnan(max1)
            IF (sawnan1) GOTO 3
 2       CONTINUE
 
         IF( .NOT.sawnan1 ) THEN
            IF( max1.LE.growthbound ) THEN
               GOTO 100
            ELSE IF( max1.LE.leastgrowth ) THEN           
               leastgrowth = max1
               bestshift = sigma
            ENDIF
         ENDIF
 3    CONTINUE
 
 
 4    CONTINUE
*
*     Shifts in the middle not tried or not succeeded
*     Find best shift on the outside of the cluster
*
*     while (KTRY <= KTRYMAX)
      ktry = 0 
*
*
*
 5    CONTINUE
 
*     Compute element growth when shifting to both ends of the cluster
*     accept shift if there is no element growth at one of the two ends
 
*     Left end
      sawnan1 = .false.
      s = -lsigma
      dplus( 1 ) = d( 1 ) + s
      max1 = abs( dplus( 1 ) )
      DO 12 bi = 1, n-1, blklen
         DO 11 i = bi, min( bi+blklen-1, n-1)
            lplus( i ) = ld( i ) / dplus( i )
            s = s*lplus( i )*l( i ) - lsigma
            dplus( i+1 ) = d( i+1 ) + s
            max1 = max( max1,abs(dplus(i+1)) )
 11      CONTINUE
         sawnan1=sawnan1 .OR. sisnan(max1)
         IF (sawnan1) GOTO 13
 12   CONTINUE
      IF( .NOT.sawnan1 ) THEN
         IF( max1.LE.growthbound ) THEN
            sigma = lsigma
            shift = sleft
            GOTO 100
         ELSE IF( max1.LE.leastgrowth ) THEN           
            leastgrowth = max1
            bestshift = lsigma
         ENDIF
      ENDIF
 13   CONTINUE
 
*     Right end      
      sawnan2 = .false.
      s = -rsigma
      work( 1 ) = d( 1 ) + s
      max2 = abs( work( 1 ) )
      DO 22 bi = 1, n-1, blklen
         DO 21 i = bi, min( bi+blklen-1, n-1)
            work( n+i ) = ld( i ) / work( i )
            s = s*work( n+i )*l( i ) - rsigma
            work( i+1 ) = d( i+1 ) + s
            max2 = max( max2,abs(work(i+1)) )
 21      CONTINUE
         sawnan2=sawnan2 .OR. sisnan(max2)
         IF (sawnan2) GOTO 23
 22   CONTINUE
      IF( .NOT.sawnan2 ) THEN
         IF( max2.LE.growthbound ) THEN
            sigma = rsigma
            shift = sright
            GOTO 100
         ELSE IF( max2.LE.leastgrowth ) THEN           
            leastgrowth = max2
            bestshift = rsigma
         ENDIF
      ENDIF
 23   CONTINUE
 
*     If we are at this point, both shifts led to too much element growth
 
 50   CONTINUE
 
      IF (ktry.LT.ktrymax) THEN
*        If we are here, both shifts failed also the RRR test.
*        Back off to the outside      
         lsigma = max( lsigma - ldelta, 
     $     lsigma - ldmax)
         rsigma = min( rsigma + rdelta, 
     $     rsigma + rdmax )
         ldelta = two * ldelta      
         rdelta = two * rdelta
*        Ensure that we do not back off too much of the initial shifts
         ldelta = min(ldmax,ldelta)
         rdelta = min(rdmax,rdelta)
         ktry = ktry + 1
         GOTO 5
      ELSE     
*        None of the representations investigated satisfied our
*        criteria. Take the best one we found.
         IF((leastgrowth.LT.fail).OR.nofail) THEN
            lsigma = bestshift
            sawnan1 = .false.
            s = -lsigma
            dplus( 1 ) = d( 1 ) + s
            DO 6 i = 1, n - 1
               lplus( i ) = ld( i ) / dplus( i )
               s = s*lplus( i )*l( i ) - lsigma
               dplus( i+1 ) = d( i+1 ) + s
               IF(abs(dplus(i+1)).LT.pivmin) THEN
                  dplus(i+1) = -pivmin
               ENDIF
 6          CONTINUE
            sigma = lsigma
            shift = sleft
            GOTO 100
         ELSE
            info = 1
            RETURN
         ENDIF
      END IF           
 
 100  CONTINUE
      IF (shift.EQ.sleft .OR. shift.EQ.smid ) THEN
      ELSEIF (shift.EQ.sright) THEN
*        store new L and D back into DPLUS, LPLUS
         CALL scopy( n, work, 1, dplus, 1 )
         CALL scopy( n-1, work(n+1), 1, lplus, 1 )
      ENDIF
 
      RETURN
*
*     End of SLARRF2
*
      END