pdlaecv()

subroutine pdlaecv	(	integer	ijob,
		integer	kf,
		integer	kl,
		double precision, dimension( * )	intvl,
		integer, dimension( * )	intvlct,
		integer, dimension( * )	nval,
		double precision	abstol,
		double precision	reltol
	)

Definition at line 1215 of file pdstebz.f.

*
*  -- ScaLAPACK routine (version 1.7) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     November 15, 1997
*
*
*     .. Scalar Arguments ..
      INTEGER            IJOB, KF, KL
      DOUBLE PRECISION   ABSTOL, RELTOL
*     ..
*     .. Array Arguments ..
      INTEGER            INTVLCT( * ), NVAL( * )
      DOUBLE PRECISION   INTVL( * )
*     ..
*
*  Purpose
*  =======
*
*  PDLAECV checks if the input intervals [ INTVL(2*i-1), INTVL(2*i) ],
*  i = KF, ... , KL-1, have "converged".
*  PDLAECV modifies KF to be the index of the last converged interval,
*  i.e., on output, all intervals [ INTVL(2*i-1), INTVL(2*i) ], i < KF,
*  have converged. Note that the input intervals may be reordered by
*  PDLAECV.
*
*  This is a SCALAPACK internal procedure and arguments are not checked
*  for unreasonable values.
*
*  Arguments
*  =========
*
*  IJOB    (input) INTEGER
*          Specifies the criterion for "convergence" of an interval.
*          = 0 : When an interval is narrower than ABSTOL, or than
*                RELTOL times the larger (in magnitude) endpoint, then
*                it is considered to have "converged".
*          = 1 : When an interval is narrower than ABSTOL, or than
*                RELTOL times the larger (in magnitude) endpoint, or if
*                the counts at the endpoints are identical to the counts
*                specified by NVAL ( see NVAL ) then the interval is
*                considered to have "converged".
*
*  KF      (input/output) INTEGER
*          On input, the index of the first input interval is 2*KF-1.
*          On output, the index of the last converged interval
*          is 2*KF-3.
*
*  KL      (input) INTEGER
*          The index of the last input interval is 2*KL-3.
*
*  INTVL   (input/output) DOUBLE PRECISION array, dimension (2*(KL-KF))
*          The endpoints of the intervals. INTVL(2*j-1) is the left
*          oendpoint f the j-th interval, and INTVL(2*j) is the right
*          endpoint of the j-th interval. The input intervals will,
*          in general, be reordered on output.
*          On input, INTVL contains the KL-KF input intervals.
*          On output, INTVL contains the converged intervals, 1 thru'
*          KF-1, and the unconverged intervals, KF thru' KL-1.
*
*  INTVLCT (input/output) INTEGER array, dimension (2*(KL-KF))
*          The counts at the endpoints of the intervals. INTVLCT(2*j-1)
*          is the count at the left endpoint of the j-th interval, i.e.,
*          the function value N(INTVL(2*j-1)), and INTVLCT(2*j) is the
*          count at the right endpoint of the j-th interval. This array
*          will, in general, be reordered on output.
*          See the comments in PDLAEBZ for more on the function N(w).
*
*  NVAL    (input/output) INTEGER array, dimension (2*(KL-KF))
*          The desired counts, N(w), at the endpoints of the
*          corresponding intervals.  This array will, in general,
*          be reordered on output.
*
*  ABSTOL  (input) DOUBLE PRECISION
*          The minimum (absolute) width of an interval. When an interval
*          is narrower than ABSTOL, or than RELTOL times the larger (in
*          magnitude) endpoint, then it is considered to be sufficiently
*          small, i.e., converged.
*          Note : This must be at least zero.
*
*  RELTOL  (input) DOUBLE PRECISION
*          The minimum relative width of an interval. When an interval
*          is narrower than ABSTOL, or than RELTOL times the larger (in
*          magnitude) endpoint, then it is considered to be sufficiently
*          small, i.e., converged.
*          Note : This should be at least radix*machine epsilon.
*
*  =====================================================================
*
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max
*     ..
*     .. Local Scalars ..
      LOGICAL            CONDN
      INTEGER            I, ITMP1, ITMP2, J, K, KFNEW
      DOUBLE PRECISION   TMP1, TMP2, TMP3, TMP4
*     ..
*     .. Executable Statements ..
*
      kfnew = kf
      DO 10 i = kf, kl - 1
         k = 2*i
         tmp3 = intvl( k-1 )
         tmp4 = intvl( k )
         tmp1 = abs( tmp4-tmp3 )
         tmp2 = max( abs( tmp3 ), abs( tmp4 ) )
         condn = tmp1.LT.max( abstol, reltol*tmp2 )
         IF( ijob.EQ.0 )
     $      condn = condn .OR. ( ( intvlct( k-1 ).EQ.nval( k-1 ) ) .AND.
     $              intvlct( k ).EQ.nval( k ) )
         IF( condn ) THEN
            IF( i.GT.kfnew ) THEN
*
*              Reorder Intervals
*
               j = 2*kfnew
               tmp1 = intvl( k-1 )
               tmp2 = intvl( k )
               itmp1 = intvlct( k-1 )
               itmp2 = intvlct( k )
               intvl( k-1 ) = intvl( j-1 )
               intvl( k ) = intvl( j )
               intvlct( k-1 ) = intvlct( j-1 )
               intvlct( k ) = intvlct( j )
               intvl( j-1 ) = tmp1
               intvl( j ) = tmp2
               intvlct( j-1 ) = itmp1
               intvlct( j ) = itmp2
               IF( ijob.EQ.0 ) THEN
                  itmp1 = nval( k-1 )
                  nval( k-1 ) = nval( j-1 )
                  nval( j-1 ) = itmp1
                  itmp1 = nval( k )
                  nval( k ) = nval( j )
                  nval( j ) = itmp1
               END IF
            END IF
            kfnew = kfnew + 1
         END IF
   10 CONTINUE
      kf = kfnew
      RETURN
*
*     End of PDLAECV
*

Here is the caller graph for this function: