smash::Integrator2d Class Reference

#include <integrate.h>

A C++ interface for numerical integration in two dimensions with the Cuba Cuhre integration function.

The algorithm is deterministic and well-suited for low dimensions, where it can reach good accuracy.

Example:

Integrator2d integrate;
const auto result = integrate(0.1, 0.9, 0., 0.5,
                              [](double x, double y) { return x * y; });

Definition at line 219 of file integrate.h.

Collaboration diagram for smash::Integrator2d:

Public Member Functions
	Integrator2d (int num_calls=1e6, double epsrel=5e-4, double epsabs=1e-9)
	Construct an integration functor. More...
template<typename F >
Result	operator() (double min1, double max1, double min2, double max2, F fun)
	The function call operator implements the integration functionality. More...

Private Attributes
int	maxeval_
	The (approximate) maximum number of integrand evaluations allowed. More...
double	epsrel_
	Requested relative accuracy. More...
double	epsabs_
	Requested absolute accuracy. More...
int	nregions_
	Actual number of subregions needed. More...
int	neval_
	Actual number of integrand evaluations needed. More...
int	fail_
	An error flag. More...
double	prob_
	The chi^2 probability that the error is not a reliable estimate of the true integration error. More...

Constructor & Destructor Documentation

Integrator2d()

smash::Integrator2d::Integrator2d ( int  num_calls = 1e6, double  epsrel = 5e-4, double  epsabs = 1e-9  )

inlineexplicit

Construct an integration functor.

Parameters

[in]	num_calls	The maximum number of calls to the integrand function (defaults to 1E6 if omitted), i.e. how often the integrand can be sampled in the integration. Larger numbers lead to a more precise result, but possibly to increased runtime.
[in]	epsrel	The desired relative accuracy (1E-3 by default).
[in]	epsabs	The desired absolute accuracy (1E-3 by default).

Definition at line 232 of file integrate.h.

      : maxeval_(num_calls), epsrel_(epsrel), epsabs_(epsabs) {}

Member Function Documentation

operator()()

template<typename F >

Result smash::Integrator2d::operator() ( double  min1, double  max1, double  min2, double  max2, F  fun  )

inline

The function call operator implements the integration functionality.

Parameters

[in]	min1	The lower limit in the first dimension.
[in]	max1	The upper limit in the first dimension.
[in]	min2	The lower limit in the second dimension.
[in]	max2	The upper limit in the second dimension.

Template Parameters

F	Type of the integrand function.

Parameters

[in]

fun

The callable to integrate over. This callable may be a function pointer, lambda, or a functor object. In any case, the callable must return a double and take two double arguments. If you want to pass additional data to the callable you can e.g. use lambda captures.

Returns

Pair of integral value and absolute error estimate.

Definition at line 253 of file integrate.h.

                                                                               {
    Result result = {0., 0.};
 
    if (max1 < min1 || max2 < min2) {
      /* Tolerance chosen large enough for floating-point arithmetic error in
       * chained decays, consider increasing if insufficient. */
      bool tolerable = (max1 - min1 > -1.e-15) && (max2 - min2 > -1.e-15);
      if (tolerable) {
        return result;
      }
      std::stringstream err;
      err << "Integrator2d got wrong integration limits: [" << min1 << ", "
          << max1 << "], [" << min2 << ", " << max2 << "]";
      throw std::invalid_argument(err.str());
    }
 
    Integrand2d<F> f_with_limits = {min1, max1 - min1, min2, max2 - min2, fun};
 
    const integrand_t cuhre_fun{[](const int * /* ndim */, const cubareal xx[],
                                   const int * /* ncomp */, cubareal ff[],
                                   void *userdata) -> int {
      auto i = static_cast<Integrand2d<F> *>(userdata);
      /* We have to transform the integrand to the unit cube.
       * This is what Cuba expects. */
      ff[0] = (i->f)(i->min1 + i->diff1 * xx[0], i->min2 + i->diff2 * xx[1]) *
              i->diff1 * i->diff2;
      return 0;
    }};
 
    const int ndim = 2;
    const int ncomp = 1;
    void *userdata = &f_with_limits;
    const int nvec = 1;
    const int flags = 0;  // Use the defaults.
    const int mineval = 0;
    const int maxeval = maxeval_;
    const int key = -1;  // Use the default.
    const char *statefile = nullptr;
    void *spin = nullptr;
 
    Cuhre(ndim, ncomp, cuhre_fun, userdata, nvec, epsrel_, epsabs_, flags,
          mineval, maxeval, key, statefile, spin, &nregions_, &neval_, &fail_,
          &result.first, &result.second, &prob_);
 
    if (fail_) {
      std::stringstream err;
      err << "After " << neval_ << " evaluations "
          << "Cuhre integration from Cuba reports error code " << fail_;
      throw std::runtime_error(err.str());
    }
    result.check_error("Cuba integration ", epsrel_, epsabs_);
 
    return result;
  }

Here is the call graph for this function:

Member Data Documentation

maxeval_

int smash::Integrator2d::maxeval_

private

The (approximate) maximum number of integrand evaluations allowed.

Definition at line 310 of file integrate.h.

epsrel_

double smash::Integrator2d::epsrel_

private

Requested relative accuracy.

Definition at line 312 of file integrate.h.

epsabs_

double smash::Integrator2d::epsabs_

private

Requested absolute accuracy.

Definition at line 314 of file integrate.h.

nregions_

int smash::Integrator2d::nregions_

private

Actual number of subregions needed.

Definition at line 316 of file integrate.h.

neval_

int smash::Integrator2d::neval_

private

Actual number of integrand evaluations needed.

Definition at line 318 of file integrate.h.

fail_

int smash::Integrator2d::fail_

private

An error flag.

0 if the desired accuracy was reached, -1 if the dimension is out of range, larger than 0 if the accuracy goal was not met within the maximum number of evaluations.

Definition at line 326 of file integrate.h.

prob_

double smash::Integrator2d::prob_

private

The chi^2 probability that the error is not a reliable estimate of the true integration error.

Definition at line 331 of file integrate.h.

---

The documentation for this class was generated from the following file:

• src/include/smash/integrate.h