dqagpe.f

Go to the documentation of this file.

      SUBROUTINE dqagpe(F,A,B,NPTS2,POINTS,EPSABS,EPSREL,LIMIT,RESULT,
     *   ABSERR,NEVAL,IER,ALIST,BLIST,RLIST,ELIST,PTS,IORD,LEVEL,NDIN,
     *   LAST)
C***BEGIN PROLOGUE  DQAGPE
C***DATE WRITTEN   800101   (YYMMDD)
C***REVISION DATE  830518   (YYMMDD)
C***CATEGORY NO.  H2A2A1
C***KEYWORDS  AUTOMATIC INTEGRATOR, GENERAL-PURPOSE,
C             SINGULARITIES AT USER SPECIFIED POINTS,
C             EXTRAPOLATION, GLOBALLY ADAPTIVE.
C***AUTHOR  PIESSENS,ROBERT ,APPL. MATH. & PROGR. DIV. - K.U.LEUVEN
C           DE DONCKER,ELISE,APPL. MATH. & PROGR. DIV. - K.U.LEUVEN
C***PURPOSE  THE ROUTINE CALCULATES AN APPROXIMATION RESULT TO A GIVEN
C            DEFINITE INTEGRAL I = INTEGRAL OF F OVER (A,B), HOPEFULLY
C            SATISFYING FOLLOWING CLAIM FOR ACCURACY ABS(I-RESULT).LE.
C            MAX(EPSABS,EPSREL*ABS(I)). BREAK POINTS OF THE INTEGRATION
C            INTERVAL, WHERE LOCAL DIFFICULTIES OF THE INTEGRAND MAY
C            OCCUR(E.G. SINGULARITIES,DISCONTINUITIES),PROVIDED BY USER.
C***DESCRIPTION
C
C        COMPUTATION OF A DEFINITE INTEGRAL
C        STANDARD FORTRAN SUBROUTINE
C        DOUBLE PRECISION VERSION
C
C        PARAMETERS
C         ON ENTRY
C            F      - SUBROUTINE F(X,IERR,RESULT) DEFINING THE INTEGRAND
C                     FUNCTION F(X). THE ACTUAL NAME FOR F NEEDS TO BE
C                     DECLARED E X T E R N A L IN THE DRIVER PROGRAM.
C
C            A      - DOUBLE PRECISION
C                     LOWER LIMIT OF INTEGRATION
C
C            B      - DOUBLE PRECISION
C                     UPPER LIMIT OF INTEGRATION
C
C            NPTS2  - INTEGER
C                     NUMBER EQUAL TO TWO MORE THAN THE NUMBER OF
C                     USER-SUPPLIED BREAK POINTS WITHIN THE INTEGRATION
C                     RANGE, NPTS2.GE.2.
C                     IF NPTS2.LT.2, THE ROUTINE WILL END WITH IER = 6.
C
C            POINTS - DOUBLE PRECISION
C                     VECTOR OF DIMENSION NPTS2, THE FIRST (NPTS2-2)
C                     ELEMENTS OF WHICH ARE THE USER PROVIDED BREAK
C                     POINTS. IF THESE POINTS DO NOT CONSTITUTE AN
C                     ASCENDING SEQUENCE THERE WILL BE AN AUTOMATIC
C                     SORTING.
C
C            EPSABS - DOUBLE PRECISION
C                     ABSOLUTE ACCURACY REQUESTED
C            EPSREL - DOUBLE PRECISION
C                     RELATIVE ACCURACY REQUESTED
C                     IF  EPSABS.LE.0
C                     AND EPSREL.LT.MAX(50*REL.MACH.ACC.,0.5D-28),
C                     THE ROUTINE WILL END WITH IER = 6.
C
C            LIMIT  - INTEGER
C                     GIVES AN UPPER BOUND ON THE NUMBER OF SUBINTERVALS
C                     IN THE PARTITION OF (A,B), LIMIT.GE.NPTS2
C                     IF LIMIT.LT.NPTS2, THE ROUTINE WILL END WITH
C                     IER = 6.
C
C         ON RETURN
C            RESULT - DOUBLE PRECISION
C                     APPROXIMATION TO THE INTEGRAL
C
C            ABSERR - DOUBLE PRECISION
C                     ESTIMATE OF THE MODULUS OF THE ABSOLUTE ERROR,
C                     WHICH SHOULD EQUAL OR EXCEED ABS(I-RESULT)
C
C            NEVAL  - INTEGER
C                     NUMBER OF INTEGRAND EVALUATIONS
C
C            IER    - INTEGER
C                     IER = 0 NORMAL AND RELIABLE TERMINATION OF THE
C                             ROUTINE. IT IS ASSUMED THAT THE REQUESTED
C                             ACCURACY HAS BEEN ACHIEVED.
C                     IER.GT.0 ABNORMAL TERMINATION OF THE ROUTINE.
C                             THE ESTIMATES FOR INTEGRAL AND ERROR ARE
C                             LESS RELIABLE. IT IS ASSUMED THAT THE
C                             REQUESTED ACCURACY HAS NOT BEEN ACHIEVED.
C                      IER.LT.0 EXIT REQUESTED FROM USER-SUPPLIED
C                             FUNCTION.
C
C            ERROR MESSAGES
C                     IER = 1 MAXIMUM NUMBER OF SUBDIVISIONS ALLOWED
C                             HAS BEEN ACHIEVED. ONE CAN ALLOW MORE
C                             SUBDIVISIONS BY INCREASING THE VALUE OF
C                             LIMIT (AND TAKING THE ACCORDING DIMENSION
C                             ADJUSTMENTS INTO ACCOUNT). HOWEVER, IF
C                             THIS YIELDS NO IMPROVEMENT IT IS ADVISED
C                             TO ANALYZE THE INTEGRAND IN ORDER TO
C                             DETERMINE THE INTEGRATION DIFFICULTIES. IF
C                             THE POSITION OF A LOCAL DIFFICULTY CAN BE
C                             DETERMINED (I.E. SINGULARITY,
C                             DISCONTINUITY WITHIN THE INTERVAL), IT
C                             SHOULD BE SUPPLIED TO THE ROUTINE AS AN
C                             ELEMENT OF THE VECTOR POINTS. IF NECESSARY
C                             AN APPROPRIATE SPECIAL-PURPOSE INTEGRATOR
C                             MUST BE USED, WHICH IS DESIGNED FOR
C                             HANDLING THE TYPE OF DIFFICULTY INVOLVED.
C                         = 2 THE OCCURRENCE OF ROUNDOFF ERROR IS
C                             DETECTED, WHICH PREVENTS THE REQUESTED
C                             TOLERANCE FROM BEING ACHIEVED.
C                             THE ERROR MAY BE UNDER-ESTIMATED.
C                         = 3 EXTREMELY BAD INTEGRAND BEHAVIOUR OCCURS
C                             AT SOME POINTS OF THE INTEGRATION
C                             INTERVAL.
C                         = 4 THE ALGORITHM DOES NOT CONVERGE.
C                             ROUNDOFF ERROR IS DETECTED IN THE
C                             EXTRAPOLATION TABLE. IT IS PRESUMED THAT
C                             THE REQUESTED TOLERANCE CANNOT BE
C                             ACHIEVED, AND THAT THE RETURNED RESULT IS
C                             THE BEST WHICH CAN BE OBTAINED.
C                         = 5 THE INTEGRAL IS PROBABLY DIVERGENT, OR
C                             SLOWLY CONVERGENT. IT MUST BE NOTED THAT
C                             DIVERGENCE CAN OCCUR WITH ANY OTHER VALUE
C                             OF IER.GT.0.
C                         = 6 THE INPUT IS INVALID BECAUSE
C                             NPTS2.LT.2 OR
C                             BREAK POINTS ARE SPECIFIED OUTSIDE
C                             THE INTEGRATION RANGE OR
C                             (EPSABS.LE.0 AND
C                              EPSREL.LT.MAX(50*REL.MACH.ACC.,0.5D-28))
C                             OR LIMIT.LT.NPTS2.
C                             RESULT, ABSERR, NEVAL, LAST, RLIST(1),
C                             AND ELIST(1) ARE SET TO ZERO. ALIST(1) AND
C                             BLIST(1) ARE SET TO A AND B RESPECTIVELY.
C
C            ALIST  - DOUBLE PRECISION
C                     VECTOR OF DIMENSION AT LEAST LIMIT, THE FIRST
C                      LAST  ELEMENTS OF WHICH ARE THE LEFT END POINTS
C                     OF THE SUBINTERVALS IN THE PARTITION OF THE GIVEN
C                     INTEGRATION RANGE (A,B)
C
C            BLIST  - DOUBLE PRECISION
C                     VECTOR OF DIMENSION AT LEAST LIMIT, THE FIRST
C                      LAST  ELEMENTS OF WHICH ARE THE RIGHT END POINTS
C                     OF THE SUBINTERVALS IN THE PARTITION OF THE GIVEN
C                     INTEGRATION RANGE (A,B)
C
C            RLIST  - DOUBLE PRECISION
C                     VECTOR OF DIMENSION AT LEAST LIMIT, THE FIRST
C                      LAST  ELEMENTS OF WHICH ARE THE INTEGRAL
C                     APPROXIMATIONS ON THE SUBINTERVALS
C
C            ELIST  - DOUBLE PRECISION
C                     VECTOR OF DIMENSION AT LEAST LIMIT, THE FIRST
C                      LAST  ELEMENTS OF WHICH ARE THE MODULI OF THE
C                     ABSOLUTE ERROR ESTIMATES ON THE SUBINTERVALS
C
C            PTS    - DOUBLE PRECISION
C                     VECTOR OF DIMENSION AT LEAST NPTS2, CONTAINING THE
C                     INTEGRATION LIMITS AND THE BREAK POINTS OF THE
C                     INTERVAL IN ASCENDING SEQUENCE.
C
C            LEVEL  - INTEGER
C                     VECTOR OF DIMENSION AT LEAST LIMIT, CONTAINING THE
C                     SUBDIVISION LEVELS OF THE SUBINTERVAL, I.E. IF
C                     (AA,BB) IS A SUBINTERVAL OF (P1,P2) WHERE P1 AS
C                     WELL AS P2 IS A USER-PROVIDED BREAK POINT OR
C                     INTEGRATION LIMIT, THEN (AA,BB) HAS LEVEL L IF
C                     ABS(BB-AA) = ABS(P2-P1)*2**(-L).
C
C            NDIN   - INTEGER
C                     VECTOR OF DIMENSION AT LEAST NPTS2, AFTER FIRST
C                     INTEGRATION OVER THE INTERVALS (PTS(I)),PTS(I+1),
C                     I = 0,1, ..., NPTS2-2, THE ERROR ESTIMATES OVER
C                     SOME OF THE INTERVALS MAY HAVE BEEN INCREASED
C                     ARTIFICIALLY, IN ORDER TO PUT THEIR SUBDIVISION
C                     FORWARD. IF THIS HAPPENS FOR THE SUBINTERVAL
C                     NUMBERED K, NDIN(K) IS PUT TO 1, OTHERWISE
C                     NDIN(K) = 0.
C
C            IORD   - INTEGER
C                     VECTOR OF DIMENSION AT LEAST LIMIT, THE FIRST K
C                     ELEMENTS OF WHICH ARE POINTERS TO THE
C                     ERROR ESTIMATES OVER THE SUBINTERVALS,
C                     SUCH THAT ELIST(IORD(1)), ..., ELIST(IORD(K))
C                     FORM A DECREASING SEQUENCE, WITH K = LAST
C                     IF LAST.LE.(LIMIT/2+2), AND K = LIMIT+1-LAST
C                     OTHERWISE
C
C            LAST   - INTEGER
C                     NUMBER OF SUBINTERVALS ACTUALLY PRODUCED IN THE
C                     SUBDIVISIONS PROCESS
C
C***REFERENCES  (NONE)
C***ROUTINES CALLED  D1MACH,DQELG,DQK21,DQPSRT
C***END PROLOGUE  DQAGPE
      DOUBLE PRECISION A,ABSEPS,ABSERR,ALIST,AREA,AREA1,AREA12,AREA2,A1,
     *  A2,B,BLIST,B1,B2,CORREC,DABS,DEFABS,DEFAB1,DEFAB2,DMAX1,DMIN1,
     *  dres,d1mach,elist,epmach,epsabs,epsrel,erlarg,erlast,errbnd,
     *  errmax,error1,erro12,error2,errsum,ertest,oflow,points,pts,
     *  resa,resabs,reseps,result,res3la,rlist,rlist2,sign,temp,uflow
      INTEGER I,ID,IER,IERRO,IND1,IND2,IORD,IP1,IROFF1,IROFF2,IROFF3,J,
     *  JLOW,JUPBND,K,KSGN,KTMIN,LAST,LEVCUR,LEVEL,LEVMAX,LIMIT,MAXERR,
     *  ndin,neval,nint,nintp1,npts,npts2,nres,nrmax,numrl2
      LOGICAL EXTRAP,NOEXT
C
C
      dimension alist(limit),blist(limit),elist(limit),iord(limit),
     *  level(limit),ndin(npts2),points(npts2),pts(npts2),res3la(3),
     *  rlist(limit),rlist2(52)
C
      EXTERNAL f
C
C            THE DIMENSION OF RLIST2 IS DETERMINED BY THE VALUE OF
C            LIMEXP IN SUBROUTINE EPSALG (RLIST2 SHOULD BE OF DIMENSION
C            (LIMEXP+2) AT LEAST).
C
C
C            LIST OF MAJOR VARIABLES
C            -----------------------
C
C           ALIST     - LIST OF LEFT END POINTS OF ALL SUBINTERVALS
C                       CONSIDERED UP TO NOW
C           BLIST     - LIST OF RIGHT END POINTS OF ALL SUBINTERVALS
C                       CONSIDERED UP TO NOW
C           RLIST(I)  - APPROXIMATION TO THE INTEGRAL OVER
C                       (ALIST(I),BLIST(I))
C           RLIST2    - ARRAY OF DIMENSION AT LEAST LIMEXP+2
C                       CONTAINING THE PART OF THE EPSILON TABLE WHICH
C                       IS STILL NEEDED FOR FURTHER COMPUTATIONS
C           ELIST(I)  - ERROR ESTIMATE APPLYING TO RLIST(I)
C           MAXERR    - POINTER TO THE INTERVAL WITH LARGEST ERROR
C                       ESTIMATE
C           ERRMAX    - ELIST(MAXERR)
C           ERLAST    - ERROR ON THE INTERVAL CURRENTLY SUBDIVIDED
C                       (BEFORE THAT SUBDIVISION HAS TAKEN PLACE)
C           AREA      - SUM OF THE INTEGRALS OVER THE SUBINTERVALS
C           ERRSUM    - SUM OF THE ERRORS OVER THE SUBINTERVALS
C           ERRBND    - REQUESTED ACCURACY MAX(EPSABS,EPSREL*
C                       ABS(RESULT))
C           *****1    - VARIABLE FOR THE LEFT SUBINTERVAL
C           *****2    - VARIABLE FOR THE RIGHT SUBINTERVAL
C           LAST      - INDEX FOR SUBDIVISION
C           NRES      - NUMBER OF CALLS TO THE EXTRAPOLATION ROUTINE
C           NUMRL2    - NUMBER OF ELEMENTS IN RLIST2. IF AN APPROPRIATE
C                       APPROXIMATION TO THE COMPOUNDED INTEGRAL HAS
C                       BEEN OBTAINED, IT IS PUT IN RLIST2(NUMRL2) AFTER
C                       NUMRL2 HAS BEEN INCREASED BY ONE.
C           ERLARG    - SUM OF THE ERRORS OVER THE INTERVALS LARGER
C                       THAN THE SMALLEST INTERVAL CONSIDERED UP TO NOW
C           EXTRAP    - LOGICAL VARIABLE DENOTING THAT THE ROUTINE
C                       IS ATTEMPTING TO PERFORM EXTRAPOLATION. I.E.
C                       BEFORE SUBDIVIDING THE SMALLEST INTERVAL WE
C                       TRY TO DECREASE THE VALUE OF ERLARG.
C           NOEXT     - LOGICAL VARIABLE DENOTING THAT EXTRAPOLATION IS
C                       NO LONGER ALLOWED (TRUE-VALUE)
C
C            MACHINE DEPENDENT CONSTANTS
C            ---------------------------
C
C           EPMACH IS THE LARGEST RELATIVE SPACING.
C           UFLOW IS THE SMALLEST POSITIVE MAGNITUDE.
C           OFLOW IS THE LARGEST POSITIVE MAGNITUDE.
C
C***FIRST EXECUTABLE STATEMENT  DQAGPE
      epmach = d1mach(4)
C
C            TEST ON VALIDITY OF PARAMETERS
C            -----------------------------
C
      ier = 0
      neval = 0
      last = 0
      result = 0.0d+00
      abserr = 0.0d+00
      alist(1) = a
      blist(1) = b
      rlist(1) = 0.0d+00
      elist(1) = 0.0d+00
      iord(1) = 0
      level(1) = 0
      npts = npts2-2
      IF(npts2.LT.2.OR.limit.LE.npts.OR.(epsabs.LE.0.0d+00.AND.
     *  epsrel.LT.dmax1(0.5d+02*epmach,0.5d-28))) ier = 6
      IF(ier.EQ.6) GO TO 999
C
C            IF ANY BREAK POINTS ARE PROVIDED, SORT THEM INTO AN
C            ASCENDING SEQUENCE.
C
      sign = 1.0d+00
      IF(a.GT.b) sign = -1.0d+00
      pts(1) = dmin1(a,b)
      IF(npts.EQ.0) GO TO 15
      DO 10 i = 1,npts
        pts(i+1) = points(i)
   10 CONTINUE
   15 pts(npts+2) = dmax1(a,b)
      nint = npts+1
      a1 = pts(1)
      IF(npts.EQ.0) GO TO 40
      nintp1 = nint+1
      DO 20 i = 1,nint
        ip1 = i+1
        DO 20 j = ip1,nintp1
          IF(pts(i).LE.pts(j)) GO TO 20
          temp = pts(i)
          pts(i) = pts(j)
          pts(j) = temp
   20 CONTINUE
      IF(pts(1).NE.dmin1(a,b).OR.pts(nintp1).NE.dmax1(a,b)) ier = 6
      IF(ier.EQ.6) GO TO 999
C
C            COMPUTE FIRST INTEGRAL AND ERROR APPROXIMATIONS.
C            ------------------------------------------------
C
   40 resabs = 0.0d+00
      DO 50 i = 1,nint
        b1 = pts(i+1)
        CALL dqk21(f,a1,b1,area1,error1,defabs,resa,ier)
        IF (ier .LT. 0) RETURN
        abserr = abserr+error1
        result = result+area1
        ndin(i) = 0
        IF(error1.EQ.resa.AND.error1.NE.0.0d+00) ndin(i) = 1
        resabs = resabs+defabs
        level(i) = 0
        elist(i) = error1
        alist(i) = a1
        blist(i) = b1
        rlist(i) = area1
        iord(i) = i
        a1 = b1
   50 CONTINUE
      errsum = 0.0d+00
      DO 55 i = 1,nint
        IF(ndin(i).EQ.1) elist(i) = abserr
        errsum = errsum+elist(i)
   55 CONTINUE
C
C           TEST ON ACCURACY.
C
      last = nint
      neval = 21*nint
      dres = dabs(result)
      errbnd = dmax1(epsabs,epsrel*dres)
      IF(abserr.LE.0.1d+03*epmach*resabs.AND.abserr.GT.errbnd) ier = 2
      IF(nint.EQ.1) GO TO 80
      DO 70 i = 1,npts
        jlow = i+1
        ind1 = iord(i)
        DO 60 j = jlow,nint
          ind2 = iord(j)
          IF(elist(ind1).GT.elist(ind2)) GO TO 60
          ind1 = ind2
          k = j
   60   CONTINUE
        IF(ind1.EQ.iord(i)) GO TO 70
        iord(k) = iord(i)
        iord(i) = ind1
   70 CONTINUE
      IF(limit.LT.npts2) ier = 1
   80 IF(ier.NE.0.OR.abserr.LE.errbnd) GO TO 210
C
C           INITIALIZATION
C           --------------
C
      rlist2(1) = result
      maxerr = iord(1)
      errmax = elist(maxerr)
      area = result
      nrmax = 1
      nres = 0
      numrl2 = 1
      ktmin = 0
      extrap = .false.
      noext = .false.
      erlarg = errsum
      ertest = errbnd
      levmax = 1
      iroff1 = 0
      iroff2 = 0
      iroff3 = 0
      ierro = 0
      uflow = d1mach(1)
      oflow = d1mach(2)
      abserr = oflow
      ksgn = -1
      IF(dres.GE.(0.1d+01-0.5d+02*epmach)*resabs) ksgn = 1
C
C           MAIN DO-LOOP
C           ------------
C
      DO 160 last = npts2,limit
C
C           BISECT THE SUBINTERVAL WITH THE NRMAX-TH LARGEST ERROR
C           ESTIMATE.
C
        levcur = level(maxerr)+1
        a1 = alist(maxerr)
        b1 = 0.5d+00*(alist(maxerr)+blist(maxerr))
        a2 = b1
        b2 = blist(maxerr)
        erlast = errmax
        CALL dqk21(f,a1,b1,area1,error1,resa,defab1,ier)
        IF (ier .LT. 0) RETURN
        CALL dqk21(f,a2,b2,area2,error2,resa,defab2,ier)
        IF (ier .LT. 0) RETURN
C
C           IMPROVE PREVIOUS APPROXIMATIONS TO INTEGRAL
C           AND ERROR AND TEST FOR ACCURACY.
C
        neval = neval+42
        area12 = area1+area2
        erro12 = error1+error2
        errsum = errsum+erro12-errmax
        area = area+area12-rlist(maxerr)
        IF(defab1.EQ.error1.OR.defab2.EQ.error2) GO TO 95
        IF(dabs(rlist(maxerr)-area12).GT.0.1d-04*dabs(area12)
     *  .OR.erro12.LT.0.99d+00*errmax) GO TO 90
        IF(extrap) iroff2 = iroff2+1
        IF(.NOT.extrap) iroff1 = iroff1+1
   90   IF(last.GT.10.AND.erro12.GT.errmax) iroff3 = iroff3+1
   95   level(maxerr) = levcur
        level(last) = levcur
        rlist(maxerr) = area1
        rlist(last) = area2
        errbnd = dmax1(epsabs,epsrel*dabs(area))
C
C           TEST FOR ROUNDOFF ERROR AND EVENTUALLY SET ERROR FLAG.
C
        IF(iroff1+iroff2.GE.10.OR.iroff3.GE.20) ier = 2
        IF(iroff2.GE.5) ierro = 3
C
C           SET ERROR FLAG IN THE CASE THAT THE NUMBER OF
C           SUBINTERVALS EQUALS LIMIT.
C
        IF(last.EQ.limit) ier = 1
C
C           SET ERROR FLAG IN THE CASE OF BAD INTEGRAND BEHAVIOUR
C           AT A POINT OF THE INTEGRATION RANGE
C
        IF(dmax1(dabs(a1),dabs(b2)).LE.(0.1d+01+0.1d+03*epmach)*
     *  (dabs(a2)+0.1d+04*uflow)) ier = 4
C
C           APPEND THE NEWLY-CREATED INTERVALS TO THE LIST.
C
        IF(error2.GT.error1) GO TO 100
        alist(last) = a2
        blist(maxerr) = b1
        blist(last) = b2
        elist(maxerr) = error1
        elist(last) = error2
        GO TO 110
  100   alist(maxerr) = a2
        alist(last) = a1
        blist(last) = b1
        rlist(maxerr) = area2
        rlist(last) = area1
        elist(maxerr) = error2
        elist(last) = error1
C
C           CALL SUBROUTINE DQPSRT TO MAINTAIN THE DESCENDING ORDERING
C           IN THE LIST OF ERROR ESTIMATES AND SELECT THE SUBINTERVAL
C           WITH NRMAX-TH LARGEST ERROR ESTIMATE (TO BE BISECTED NEXT).
C
  110   CALL dqpsrt(limit,last,maxerr,errmax,elist,iord,nrmax)
C ***JUMP OUT OF DO-LOOP
        IF(errsum.LE.errbnd) GO TO 190
C ***JUMP OUT OF DO-LOOP
        IF(ier.NE.0) GO TO 170
        IF(noext) GO TO 160
        erlarg = erlarg-erlast
        IF(levcur+1.LE.levmax) erlarg = erlarg+erro12
        IF(extrap) GO TO 120
C
C           TEST WHETHER THE INTERVAL TO BE BISECTED NEXT IS THE
C           SMALLEST INTERVAL.
C
        IF(level(maxerr)+1.LE.levmax) GO TO 160
        extrap = .true.
        nrmax = 2
  120   IF(ierro.EQ.3.OR.erlarg.LE.ertest) GO TO 140
C
C           THE SMALLEST INTERVAL HAS THE LARGEST ERROR.
C           BEFORE BISECTING DECREASE THE SUM OF THE ERRORS OVER
C           THE LARGER INTERVALS (ERLARG) AND PERFORM EXTRAPOLATION.
C
        id = nrmax
        jupbnd = last
        IF(last.GT.(2+limit/2)) jupbnd = limit+3-last
        DO 130 k = id,jupbnd
          maxerr = iord(nrmax)
          errmax = elist(maxerr)
C ***JUMP OUT OF DO-LOOP
          IF(level(maxerr)+1.LE.levmax) GO TO 160
          nrmax = nrmax+1
  130   CONTINUE
C
C           PERFORM EXTRAPOLATION.
C
  140   numrl2 = numrl2+1
        rlist2(numrl2) = area
        IF(numrl2.LE.2) GO TO 155
        CALL dqelg(numrl2,rlist2,reseps,abseps,res3la,nres)
        ktmin = ktmin+1
        IF(ktmin.GT.5.AND.abserr.LT.0.1d-02*errsum) ier = 5
        IF(abseps.GE.abserr) GO TO 150
        ktmin = 0
        abserr = abseps
        result = reseps
        correc = erlarg
        ertest = dmax1(epsabs,epsrel*dabs(reseps))
C ***JUMP OUT OF DO-LOOP
        IF(abserr.LT.ertest) GO TO 170
C
C           PREPARE BISECTION OF THE SMALLEST INTERVAL.
C
  150   IF(numrl2.EQ.1) noext = .true.
        IF(ier.GE.5) GO TO 170
  155   maxerr = iord(1)
        errmax = elist(maxerr)
        nrmax = 1
        extrap = .false.
        levmax = levmax+1
        erlarg = errsum
  160 CONTINUE
C
C           SET THE FINAL RESULT.
C           ---------------------
C
C
  170 IF(abserr.EQ.oflow) GO TO 190
      IF((ier+ierro).EQ.0) GO TO 180
      IF(ierro.EQ.3) abserr = abserr+correc
      IF(ier.EQ.0) ier = 3
      IF(result.NE.0.0d+00.AND.area.NE.0.0d+00)GO TO 175
      IF(abserr.GT.errsum)GO TO 190
      IF(area.EQ.0.0d+00) GO TO 210
      GO TO 180
  175 IF(abserr/dabs(result).GT.errsum/dabs(area))GO TO 190
C
C           TEST ON DIVERGENCE.
C
  180 IF(ksgn.EQ.(-1).AND.dmax1(dabs(result),dabs(area)).LE.
     *  resabs*0.1d-01) GO TO 210
      IF(0.1d-01.GT.(result/area).OR.(result/area).GT.0.1d+03.OR.
     *  errsum.GT.dabs(area)) ier = 6
      GO TO 210
C
C           COMPUTE GLOBAL INTEGRAL SUM.
C
  190 result = 0.0d+00
      DO 200 k = 1,last
        result = result+rlist(k)
  200 CONTINUE
      abserr = errsum
  210 IF(ier.GT.2) ier = ier-1
      result = result*sign
  999 RETURN
      END