smash::Integrator1dMonte Class Reference

#include <integrate.h>

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

Example:

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

Definition at line 188 of file integrate.h.

Collaboration diagram for smash::Integrator1dMonte:

Public Member Functions
	Integrator1dMonte (size_t num_calls=1E6)
	Construct an integration functor. More...
	~Integrator1dMonte ()
	Destructor: Clean up internal state and RNG. More...
template<typename F >
Result	operator() (double min, double max, 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

smash::Integrator1dMonte::Integrator1dMonte ( 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 204 of file integrate.h.

      : state_(gsl_monte_plain_alloc(1)),
        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:

smash::Integrator1dMonte::~Integrator1dMonte ( )

inline

Destructor: Clean up internal state and RNG.

Definition at line 215 of file integrate.h.

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

Member Function Documentation

template<typename F >

Result smash::Integrator1dMonte::operator() ( double  min, double  max, F &&  fun  )

inline

The function call operator implements the integration functionality.

Parameters

[in]	min	The lower limit of the integration.
[in]	max	The upper limit of the integration.

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

                                                     {
    Result result = {0, 0};

    const double lower[1] = {min};
    const double upper[1] = {max};

    if (max <= min)
      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]);
        },
        1, &fun};

    const int error_code =
        gsl_monte_plain_integrate(&monte_fun, lower, upper, 1, number_of_calls_,
                                  rng_, state_, &result.first, &result.second);
    if (error_code) {
      std::stringstream err;
      err << "GSL 1D Monte-Carlo integration: " << gsl_strerror(error_code);
      throw std::runtime_error(err.str());
    }

    result.check_error("GSL 1D Monte-Carlo integration");

    return result;
  }

Here is the call graph for this function:

Member Data Documentation

gsl_monte_plain_state* smash::Integrator1dMonte::state_

private

internal state of the Monte-Carlo integrator

Definition at line 268 of file integrate.h.

gsl_rng* smash::Integrator1dMonte::rng_

private

random number generator

Definition at line 271 of file integrate.h.

const std::size_t smash::Integrator1dMonte::number_of_calls_

private

number of calls to the integrand

Definition at line 274 of file integrate.h.

---

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

• src/include/smash/integrate.h