smash::Integrator2d Class Reference

#include <integrate.h>

A C++ interface for numerical integration in two dimensions with the GSL Monte-Carlo integration functions.

Example:

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

Definition at line 288 of file integrate.h.

Collaboration diagram for smash::Integrator2d:

Public Member Functions
	Integrator2d (size_t num_calls=1E6)
	Construct an integration functor. More...
	~Integrator2d ()
	Destructor: Clean up internal state and RNG. 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
gsl_monte_plain_state *	state_
	internal state of the Monte-Carlo integrator More...
gsl_rng *	rng_
	random number generator More...
const std::size_t	number_of_calls_
	number of calls to the integrand More...

Constructor & Destructor Documentation

Integrator2d()

smash::Integrator2d::Integrator2d ( size_t  num_calls = 1E6 )

inlineexplicit

Construct an integration functor.

Parameters

[in]

num_calls

The desired number of calls to the integrand function (defaults to 1E6 if omitted), i.e. how often the integrand is sampled in the Monte-Carlo integration. Larger numbers lead to a more precise result, but also to increased runtime.

Note

Since the workspace is allocated in the constructor and deallocated on destruction, you should not recreate Integrator objects unless required. Thus, if you want to calculate multiple integrals with the same workspace_size, keep the Integrator object around.

Definition at line 304 of file integrate.h.

      : state_(gsl_monte_plain_alloc(2)),
        rng_(gsl_rng_alloc(gsl_rng_mt19937)),
        number_of_calls_(num_calls) {
    gsl_monte_plain_init(state_);
    // initialize the GSL RNG with a random seed
    const uint32_t seed = random::uniform_int(0ul, ULONG_MAX);
    gsl_rng_set(rng_, seed);
  }

Here is the call graph for this function:

~Integrator2d()

smash::Integrator2d::~Integrator2d ( )

inline

Destructor: Clean up internal state and RNG.

Definition at line 315 of file integrate.h.

                  {
    gsl_monte_plain_free(state_);
    gsl_rng_free(rng_);
  }

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 337 of file integrate.h.

                             {
    Result result = {0, 0};

    const double lower[2] = {min1, min2};
    const double upper[2] = {max1, max2};

    if (max1 <= min1 || max2 <= min2)
      return result;

    const gsl_monte_function monte_fun{
        // trick: pass integrand function as 'params'
        [](double *x, size_t /*dim*/, void *params) -> double {
          auto &&f = *static_cast<F *>(params);
          return f(x[0], x[1]);
        },
        2, &fun};

    gsl_monte_plain_integrate(&monte_fun, lower, upper, 2, number_of_calls_,
                              rng_, state_, &result.first, &result.second);

    return result;
  }

Member Data Documentation

state_

gsl_monte_plain_state* smash::Integrator2d::state_

private

internal state of the Monte-Carlo integrator

Definition at line 363 of file integrate.h.

rng_

gsl_rng* smash::Integrator2d::rng_

private

random number generator

Definition at line 366 of file integrate.h.

number_of_calls_

const std::size_t smash::Integrator2d::number_of_calls_

private

number of calls to the integrand

Definition at line 369 of file integrate.h.

---

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

• src/include/smash/integrate.h