d9/d53/qagi_8f_source.html

      subroutine qagi(f,bound,inf,epsabs,epsrel,result,abserr,neval,

     *   ier,limit,lenw,last,iwork,work)

c***begin prologue  qagi

c***date written   800101   (yymmdd)

c***revision date  830518   (yymmdd)

c***category no.  h2a3a1,h2a4a1

c***keywords  automatic integrator, infinite intervals,

c             general-purpose, transformation, extrapolation,

c             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            integral   i = integral of f over (bound,+infinity)

c                    or i = integral of f over (-infinity,bound)

c                    or i = integral of f over (-infinity,+infinity)

c            hopefully satisfying following claim for accuracy

c            abs(i-result).le.max(epsabs,epsrel*abs(i)).

c***description

c

c        integration over infinite intervals

c        standard fortran subroutine

c

c        parameters

c         on entry

c            f      - subroutine f(x,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            bound  - real

c                     finite bound of integration range

c                     (has no meaning if interval is doubly-infinite)

c

c            inf    - integer

c                     indicating the kind of integration range involved

c                     inf = 1 corresponds to  (bound,+infinity),

c                     inf = -1            to  (-infinity,bound),

c                     inf = 2             to (-infinity,+infinity).

c

c            epsabs - real

c                     absolute accuracy requested

c            epsrel - real

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

c         on return

c            result - real

c                     approximation to the integral

c

c            abserr - real

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. the

c                             estimates for result and error are less

c                             reliable. it is assumed that the requested

c                             accuracy has not been achieved.

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 (e.g. singularity,

c                             discontinuity within the interval) one

c                             will probably gain from splitting up the

c                             interval at this point and calling the

c                             integrator on the subranges. if possible,

c                             an appropriate special-purpose integrator

c                             should 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.

c                             it is assumed that the requested tolerance

c                             cannot be achieved, and that the returned

c                             result is 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.

c                         = 6 the input is invalid, because

c                             (epsabs.le.0 and

c                              epsrel.lt.max(50*rel.mach.acc.,0.5d-28))

c                              or limit.lt.1 or leniw.lt.limit*4.

c                             result, abserr, neval, last are set to

c                             zero. exept when limit or leniw is

c                             invalid, iwork(1), work(limit*2+1) and

c                             work(limit*3+1) are set to zero, work(1)

c                             is set to a and work(limit+1) to b.

c

c         dimensioning parameters

c            limit - integer

c                    dimensioning parameter for iwork

c                    limit determines the maximum number of subintervals

c                    in the partition of the given integration interval

c                    (a,b), limit.ge.1.

c                    if limit.lt.1, the routine will end with ier = 6.

c

c            lenw  - integer

c                    dimensioning parameter for work

c                    lenw must be at least limit*4.

c                    if lenw.lt.limit*4, the routine will end

c                    with ier = 6.

c

c            last  - integer

c                    on return, last equals the number of subintervals

c                    produced in the subdivision process, which

c                    determines the number of significant elements

c                    actually in the work arrays.

c

c         work arrays

c            iwork - integer

c                    vector of dimension at least limit, the first

c                    k elements of which contain pointers

c                    to the error estimates over the subintervals,

c                    such that work(limit*3+iwork(1)),... ,

c                    work(limit*3+iwork(k)) form a decreasing

c                    sequence, with k = last if last.le.(limit/2+2), and

c                    k = limit+1-last otherwise

c

c            work  - real

c                    vector of dimension at least lenw

c                    on return

c                    work(1), ..., work(last) contain the left

c                     end points of the subintervals in the

c                     partition of (a,b),

c                    work(limit+1), ..., work(limit+last) contain

c                     the right end points,

c                    work(limit*2+1), ...,work(limit*2+last) contain the

c                     integral approximations over the subintervals,

c                    work(limit*3+1), ..., work(limit*3)

c                     contain the error estimates.

c***references  (none)

c***routines called  qagie,xerror

c***end prologue  qagi

c

      real   abserr,  epsabs,epsrel,result,work

      integer ier,iwork,    lenw,limit,lvl,l1,l2,l3,neval

c

      dimension iwork(limit),work(lenw)

c

      external f

c

c         check validity of limit and lenw.

c

c***first executable statement  qagi

      ier = 6

      neval = 0

      last = 0

      result = 0.0e+00

      abserr = 0.0e+00

      if(limit.lt.1.or.lenw.lt.limit*4) go to 10

c

c         prepare call for qagie.

c

      l1 = limit+1

      l2 = limit+l1

      l3 = limit+l2

c

      call qagie(f,bound,inf,epsabs,epsrel,limit,result,abserr,

     *  neval,ier,work(1),work(l1),work(l2),work(l3),iwork,last)

c

c         call error handler if necessary.

c

      lvl = 0

10    if(ier.eq.6) lvl = 1

      if(ier.ne.0) call xerror('abnormal return from  qagi',26,ier,lvl)

      return


      end

qagi
subroutine qagi(f, bound, inf, epsabs, epsrel, result, abserr, neval, ier, limit, lenw, last, iwork, work)
Definition qagi.f:3

qagie
subroutine qagie(f, bound, inf, epsabs, epsrel, limit, result, abserr, neval, ier, alist, blist, rlist, elist, iord, last)
Definition qagie.f:3

xerror
subroutine xerror(messg, nmessg, nerr, level)
Definition xerror.f:2