Class template adaptive

Class template adaptive_alg

boost::numeric::quadrature::adaptive_alg — Global, adaptive integration.

Synopsis

template<BOOST_QUADRATURE_ARG_TEMPLATE(Kernel) , 
         BOOST_QUADRATURE_ARG_TEMPLATE(RelAcc) , 
         BOOST_QUADRATURE_ARG_TEMPLATE(AbsAcc) , 
         BOOST_QUADRATURE_ARG_TEMPLATE(MaxInt) , 
         BOOST_QUADRATURE_ARG_TEMPLATE(Info) , 
         BOOST_QUADRATURE_ARG_TEMPLATE(Accel) , 
         BOOST_QUADRATURE_ARG_TEMPLATE(Intervals) > 
class adaptive_alg {
public:
  // construct/copy/destruct
  adaptive_alg(unspecified = unspecified, unspecified = unspecified, 
               unspecified = unspecified, unspecified = unspecified, 
               unspecified = unspecified, unspecified = unspecified, 
               unspecified = unspecified, unspecified = unspecified);

  // public member functions
  template<typename F, typename DL, typename DU, typename R> 
    quadrature_error operator()(F, DL, DU, R &, R &) ;
  template<typename Kernel_> 
    adaptive_alg< Kernel_, RelAcc, AbsAcc, MaxInt, Info, Accel, Intervals, Recorder > 
    kernel(const Kernel_ &) ;
  template<typename Info_> 
    adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info_, Accel, Intervals, Recorder > 
    info(Info_ &) ;
  template<typename RelAcc_> 
    adaptive_alg< Kernel, RelAcc_, AbsAcc, MaxInt, Info, Accel, Intervals, Recorder > 
    relative_accuracy(RelAcc_) ;
  template<typename AbsAcc_> 
    adaptive_alg< Kernel, RelAcc, AbsAcc_, MaxInt, Info, Accel, Intervals, Recorder > 
    absolute_accuracy(AbsAcc_) ;
  template<typename MaxInt_> 
    adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt_, Info, Accel, Intervals, Recorder > 
    max_intervals(MaxInt_) ;
  template<typename Intervals_> 
    adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info, Accel, Intervals_, Recorder > 
    intervals(Intervals_ &) ;
  template<typename Accel_> 
    adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info, Accel_, Intervals, Recorder > 
    accelerator(Accel_ &) ;
  template<typename Recorder_> 
    adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info, Accel, Intervals, Recorder_ > 
    recorder(Recorder_ &) ;
};

Description

Based on QUADPACK QAG and QAGS and the bisection of the interval of integration.

`adaptive_alg` construct/copy/destruct

adaptive_alg(unspecified kernel = unspecified, 
             unspecified relative_accuracy = unspecified, 
             unspecified absolute_accuracy = unspecified, 
             unspecified max_intervals = unspecified, 
             unspecified info = unspecified, unspecified accel = unspecified, 
             unspecified intervals = unspecified, 
             unspecified recorder = unspecified);

`adaptive_alg` public member functions

template<typename F, typename DL, typename DU, typename R> 
  quadrature_error 
  operator()(F integrand, DL lower_limit, DU upper_limit, R & result, 
             R & error) ;

Integrates the specified functor between lower_limit and upper_limit.

Parameters:

`error`	estimation of absolute error in integral approximation
`integrand`	function to be integrated
`lower_limit`	lower bound on range of integration
`result`	approximation of integral
`upper_limit`	upper bound on range of integration

Returns:

Error code. invalid_input if, epsabs<0 and epsrel<max(50*epsilon,0.5e-28) or size(interval_storage)<1

template<typename Kernel_> 
  adaptive_alg< Kernel_, RelAcc, AbsAcc, MaxInt, Info, Accel, Intervals, Recorder > 
  kernel(const Kernel_ & kernel) ;

Supply integration kernel

Parameters:

kernel

the integration kernel to be used

Returns:

an adaptive integrator object, which includes the kernel

template<typename Info_> 
  adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info_, Accel, Intervals, Recorder > 
  info(Info_ & info) ;

Supply info

Parameters:

info

the adaptive info to be used

Returns:

an adaptive integrator object, which includes the info

template<typename RelAcc_> 
  adaptive_alg< Kernel, RelAcc_, AbsAcc, MaxInt, Info, Accel, Intervals, Recorder > 
  relative_accuracy(RelAcc_ accuracy) ;

Supply relative accuracy

Parameters:

accuracy

the relative accuracy to be used

Returns:

an adaptive integrator object, which includes the relative accuracy

template<typename AbsAcc_> 
  adaptive_alg< Kernel, RelAcc, AbsAcc_, MaxInt, Info, Accel, Intervals, Recorder > 
  absolute_accuracy(AbsAcc_ accuracy) ;

Parameters:

accuracy

the absolute accuracy to be used

Returns:

an adaptive integrator object, which includes the absolute accuracy

template<typename MaxInt_> 
  adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt_, Info, Accel, Intervals, Recorder > 
  max_intervals(MaxInt_ num_intervals) ;

Supply max intervals

Parameters:

num_intervals

the max number of intervals to be used

Returns:

an adaptive integrator object, which includes the max intervals

template<typename Intervals_> 
  adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info, Accel, Intervals_, Recorder > 
  intervals(Intervals_ & intervals) ;

Supply interval storage

Parameters:

intervals

the interval storage to be used

Returns:

an adaptive integrator object, which includes the interval storage

template<typename Accel_> 
  adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info, Accel_, Intervals, Recorder > 
  accelerator(Accel_ & accelerator) ;

Supply accelerator

Parameters:

accelerator

the accelerator to be used

Returns:

an adaptive integrator object, which includes the accelerator

template<typename Recorder_> 
  adaptive_alg< Kernel, RelAcc, AbsAcc, MaxInt, Info, Accel, Intervals, Recorder_ > 
  recorder(Recorder_ & recorder) ;

Parameters:

recorder

the recorder to be used

Returns:

an adaptive integrator object, which includes the recorder