Sayısal entegrasyon için C ++ kütüphanesi (kareleme)

1967'de Bulirsch & Stoer tarafından yayınlanan bir ALGOL programının C ++ uyarlaması olan sayısal entegrasyon (kareleme) için kendi küçük alt programım var (Numerische Mathematik, 9, 271-278).

Daha modern (uyarlanabilir) bir algoritmaya yükseltmek ve böyle bir (ücretsiz) C ++ kütüphanesi olup olmadığını merak ediyorum. GSL (ki bu C) olarak bir göz vardı, ama (nümerik iyi olabilir) korkunç bir API ile geliyor. Başka bir şey var mı?

Yararlı bir API şöyle görünür:

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

Odeint'e bir bakın . Artık Boost'un bir parçası ve diğerleri arasında Bulirsch-Stoer algoritmasını içeriyor. Başlamak için burada çok basit bir örnek görebilirsiniz.

GSL kareleme fonksiyonlarının etrafına kolayca ince bir C ++ sarmalayıcısı yazabilirsiniz. Aşağıdakiler C ++ 11 gerektirir.

#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';
}

Çıktı

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

MFEM [1] kullanımı kolay kareleme fonksiyonlarına sahiptir (hem yüzeysel hem de hacimsel elemanlar için). Bunları çeşitli görevler için kullanabildik.

[1] http://mfem.org/

Cubature kütüphanesi ile başarılı oldum (yine de C ile yazılmış). Nispeten az sayıda boyutla çok boyutlu entegrasyonu hedeflemektedir.

HIntLib kütüphanesi C ++ ile yazılmıştır ve adaptif dört evreli (cubature) için rutinleri vardır.

Https://github.com/tbs1980/NumericalIntegration sayfasına göz atın . QUADPACK'e (GSL'nin de dayandığı) dayanmaktadır ve örneğin Eigen, çoklu hassasiyet desteği gibi bazı modern özelliklere sahiptir.