C ++ - Bibliothek zur numerischen Integration (Quadratur)

Ich habe meine eigene kleine Subroutine für die numerische Integration (Quadratur), eine C ++ - Adaption eines ALGOL-Programms, das 1967 von Bulirsch & Stoer veröffentlicht wurde (Numerische Mathematik, 9, 271-278).

Ich möchte auf einen moderneren (adaptiven) Algorithmus upgraden und mich fragen, ob es (kostenlose) C ++ - Bibliotheken gibt, die solche anbieten. Ich habe nach GSL gesucht (das ist C), aber das kommt mit einer schrecklichen API (obwohl die Zahlen gut sein können). Gibt es noch etwas?

Eine nützliche API würde folgendermaßen aussehen:

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);

Schauen Sie sich Odeint an . Es ist jetzt Teil von Boost und enthält unter anderem den Bulirsch-Stoer-Algorithmus. Zu Beginn sehen Sie hier ein sehr einfaches Beispiel.

MFEM [1] verfügt über benutzerfreundliche Quadraturfunktionen (sowohl für Oberflächen- als auch für Volumenelemente). Wir konnten sie für verschiedene Aufgaben einsetzen.

[1] http://mfem.org/

Sie können leicht einen dünnen C ++ - Wrapper um die GSL-Quadraturfunktionen schreiben. Folgendes benötigt 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';
}

Ausgabe

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

Ich hatte Erfolg mit der Cubature-Bibliothek (sie ist jedoch in C geschrieben). Es zielt auf eine mehrdimensionale Integration mit einer relativ geringen Anzahl von Dimensionen ab.

Die HIntLib-Bibliothek ist in C ++ geschrieben und verfügt über Routinen für die adaptive Quadratur (Kubatur).

Überprüfen Sie https://github.com/tbs1980/NumericalIntegration . Es basiert auf QUADPACK (auf dem auch GSL basiert) und verfügt über einige nette moderne Funktionen, z. B. basierend auf Eigen, Multiprezisionsunterstützung.