Package netlib.quadpack

Class Dqage

java.lang.Object
netlib.quadpack.Dqage
public class Dqage
extends java.lang.Object
(Adaptive) Computation of a Definite Integral.

The static method dqage(...) performs an adapive integration.
The static method getIntegrationRule(...) is a factory method for Dqk-objects. 


  Produced by f2java.  f2java is part of the Fortran-
  -to-Java project at the University of Tennessee Netlib
  numerical software repository.

  Original authorship for the BLAS and LAPACK numerical
  routines may be found in the Fortran source, available at
  http://www.netlib.org.

  Fortran input file: dqage.f
  f2java version: 0.8.1


// c***begin prologue  dqage
// c***date written   800101   (yymmdd)
// c***revision date  830518   (yymmdd)
// c***category no.  h2a1a1
// c***keywords  automatic integrator, general-purpose,
// c             integrand examinator, globally adaptive,
// c             gauss-kronrod
// 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),
// c            hopefully satisfying following claim for accuracy
// c            abs(i-reslt).le.max(epsabs,epsrel*abs(i)).
// 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      - double precision
// c                     function subprogram 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            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            key    - integer
// c                     key for choice of local integration rule
// c                     a gauss-kronrod pair is used with
// c                          7 - 15 points if key.lt.2,
// c                         10 - 21 points if key = 2,
// c                         15 - 31 points if key = 3,
// c                         20 - 41 points if key = 4,
// c                         25 - 51 points if key = 5,
// c                         30 - 61 points if key.gt.5.
// c
// c            limit  - integer
// c                     gives an upperbound on the number of subintervals
// c                     in the partition of (a,b), limit.ge.1.
// 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 result and error are
// c                             less reliable. it is assumed that the
// c                             requested 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
// c                             of limit.
// c                             however, if this yields no improvement it
// c                             is rather advised to analyze the integrand
// c                             in order to determine the integration
// c                             difficulties. if the position of a local
// c                             difficulty can be determined(e.g.
// c                             singularity, discontinuity within the
// c                             interval) one will probably gain from
// c                             splitting up the interval at this point
// c                             and calling the integrator on the
// c                             subranges. if possible, an appropriate
// c                             special-purpose integrator should be used
// c                             which is designed for handling the type of
// c                             difficulty involved.
// c                         = 2 the occurrence of roundoff error is
// c                             detected, which prevents the requested
// c                             tolerance from being achieved.
// c                         = 3 extremely bad integrand behaviour occurs
// c                             at some points of the integration
// c                             interval.
// c                         = 6 the input is invalid, because
// c                             (epsabs.le.0 and
// c                              epsrel.lt.max(50*rel.mach.acc.,0.5d-28),
// c                             result, abserr, neval, last, rlist(1) ,
// c                             elist(1) and iord(1) are set to zero.
// c                             alist(1) and blist(1) are set to a and b
// c                             respectively.
// c
// c            alist   - double precision
// c                      vector of dimension at least limit, the first
// c                       last  elements of which are the left
// c                      end points of the subintervals in the partition
// c                      of the given 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
// c                      end points of the subintervals in the partition
// c                      of the given 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
// c                      integral 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            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)), ...,
// c                      elist(iord(k)) form a decreasing sequence,
// c                      with k = last if last.le.(limit/2+2), and
// c                      k = limit+1-last otherwise
// c
// c            last    - integer
// c                      number of subintervals actually produced in the
// c                      subdivision process
// c
// c***references  (none)
// c***routines called  d1mach,dqk15,dqk21,dqk31,
// c                    dqk41,dqk51,dqk61,dqpsrt
// c***end prologue  dqage
// c
// c
// 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           elist(i)  - error estimate applying to rlist(i)
// c           maxerr    - pointer to the interval with largest
// c                       error estimate
// c           errmax    - elist(maxerr)
// 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
// c
// c           machine dependent constants
// c           ---------------------------
// c
// c           epmach  is the largest relative spacing.
// c           uflow  is the smallest positive magnitude.
// c

  • Method Summary

    Modifier and Type Method Description
    static void dqage​(UnivariateDoubleFunction fun, double a, double b, double epsabs, double epsrel, int key, int limit, doubleW result, doubleW abserr, intW neval, intW ier, double[] alist, int _alist_offset, double[] blist, int _blist_offset, double[] rlist, int _rlist_offset, double[] elist, int _elist_offset, int[] iord, int _iord_offset, intW last)  
    static int getEvaluationsPerInterval​(int key)
    Anzahl der pro Intervall benötigten Funktionsaufrufe.
    static Dqk getIntegrationRule​(int key)  

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait