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

xerror
subroutine xerror(MESSG, NMESSG, NERR, LEVEL)
Definition: xerror.f:1

workspace_element::dimension
std::string dimension(void) const
Definition: workspace-element.h:74

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

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