Bibliothèque C ++ pour l'intégration numérique (quadrature)

J'ai mon propre petit sous-programme d'intégration numérique (quadrature), qui est une adaptation en C ++ d'un programme ALGOL publié par Bulirsch & Stoer en 1967 (Numerische Mathematik, 9, 271-278).

Je voudrais passer à un algorithme plus moderne (adaptatif) et me demander s'il existe des bibliothèques C ++ (gratuites) qui en fournissent. J'avais un look GSL (qui est C), mais cela vient avec une horrible API (bien que les chiffres soient bons). Y a-t-il autre chose?

Une API utile ressemblerait à ceci:

double quadrature(double lower_integration_limit,
                  double upper_integration_limit,
                  std::function<double(double)> const&func,
                  double desired_error_bound_relative=1.e-12,
                  double desired_error_bound_absolute=0,
                  double*error_estimate=nullptr);

Jetez un oeil à Odeint . Il fait maintenant partie de Boost et inclut entre autres l'algorithme Bulirsch-Stoer. Pour commencer, vous pouvez voir ici un exemple très simple.

MFEM [1] possède des fonctions de quadrature faciles à utiliser (pour les éléments surfaciques et volumétriques). Nous avons pu les utiliser pour diverses tâches.

[1] http://mfem.org/

Vous pouvez facilement écrire un wrapper C ++ fin autour des fonctions de quadrature GSL. Les éléments suivants ont besoin de C ++ 11.

#include <iostream>
#include <cmath>

#include <functional>
#include <memory>
#include <utility>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_integration.h>

template < typename F >
class gsl_quad
{
  F f;
  int limit;
  std::unique_ptr < gsl_integration_workspace,
                    std::function < void(gsl_integration_workspace*) >
                    > workspace;

  static double gsl_wrapper(double x, void * p)
  {
    gsl_quad * t = reinterpret_cast<gsl_quad*>(p);
    return t->f(x);
  }

public:
  gsl_quad(F f, int limit)
    : f(f)
    , limit(limit)
    , workspace(gsl_integration_workspace_alloc(limit), gsl_integration_workspace_free)
  {}

  double integrate(double min, double max, double epsabs, double epsrel)
  {
    gsl_function gsl_f;
    gsl_f.function = &gsl_wrapper;
    gsl_f.params = this;

    double result, error;
    if ( !std::isinf(min) && !std::isinf(max) )
    {
      gsl_integration_qags ( &gsl_f, min, max,
                             epsabs, epsrel, limit,
                             workspace.get(), &result, &error );
    }
    else if ( std::isinf(min) && !std::isinf(max) )
    {
      gsl_integration_qagil( &gsl_f, max,
                             epsabs, epsrel, limit,
                             workspace.get(), &result, &error );
    }
    else if ( !std::isinf(min) && std::isinf(max) )
    {
      gsl_integration_qagiu( &gsl_f, min,
                             epsabs, epsrel, limit,
                             workspace.get(), &result, &error );
    }
    else
    {
      gsl_integration_qagi ( &gsl_f,
                             epsabs, epsrel, limit,
                             workspace.get(), &result, &error );
    }

    return result;
  }
};

template < typename F >
double quad(F func,
            std::pair<double,double> const& range,
            double epsabs = 1.49e-8, double epsrel = 1.49e-8,
            int limit = 50)
{
  return gsl_quad<F>(func, limit).integrate(range.first, range.second, epsabs, epsrel);
}

int main()
{
  std::cout << "\\int_0^1 x^2 dx = "
            << quad([](double x) { return x*x; }, {0,1}) << '\n'
            << "\\int_1^\\infty x^{-2} dx = "
            << quad([](double x) { return 1/(x*x); }, {1,INFINITY}) << '\n'
            << "\\int_{-\\infty}^\\infty \\exp(-x^2) dx = "
            << quad([](double x) { return std::exp(-x*x); }, {-INFINITY,INFINITY}) << '\n';
}

Production

\int_0^1 x^2 dx = 0.333333
\int_1^\infty x^{-2} dx = 1
\int_{-\infty}^\infty \exp(-x^2) dx = 1.77245

J'ai eu du succès avec la bibliothèque Cubature (elle est cependant écrite en C). Il vise une intégration multidimensionnelle avec un nombre de dimensions relativement faible.

La bibliothèque HIntLib est écrite en C ++ et possède des routines pour la quadrature adaptative (cubature).

Consultez https://github.com/tbs1980/NumericalIntegration . Il est basé sur QUADPACK (sur lequel GSL est également basé) et possède des fonctionnalités modernes soignées, par exemple basées sur Eigen, un support multiprécision.