Pustaka C ++ untuk intergrasi numerik (quadrature)

Saya memiliki subrutin kecil saya sendiri untuk integrasi numerik (quadrature), yang merupakan adaptasi C ++ dari program ALGOL yang diterbitkan oleh Bulirsch & Stoer pada tahun 1967 (Numerische Mathematik, 9, 271-278).

Saya ingin meningkatkan ke algoritma yang lebih modern (adaptif) dan bertanya-tanya apakah ada perpustakaan C ++ (gratis) yang menyediakannya. Saya telah melihat sebagai GSL (yang merupakan C), tetapi itu datang dengan API yang mengerikan (meskipun angka mungkin baik). Apakah ada hal lain?

API yang bermanfaat akan terlihat seperti ini:

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

Lihatlah Odeint . Sekarang bagian dari Boost dan termasuk algoritma Bulirsch-Stoer. Untuk memulai, Anda dapat melihat di sini contoh yang sangat sederhana.

MFEM [1] memiliki fungsi quadrature yang mudah digunakan (baik untuk elemen permukaan dan volumetrik). Kami dapat menggunakannya untuk berbagai tugas.

[1] http://mfem.org/

Anda dapat dengan mudah menulis bungkus C ++ tipis di sekitar fungsi quadrature GSL. Kebutuhan berikut 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';
}

Keluaran

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

Saya telah sukses dengan perpustakaan Cubature (ditulis dalam C, meskipun). Ini ditujukan untuk integrasi multidimensi dengan jumlah dimensi yang relatif rendah.

The HIntLib perpustakaan ditulis dalam C ++ dan memiliki rutinitas untuk kuadratur adaptif (cubature).

Lihat https://github.com/tbs1980/NumericalIntegration . Ini didasarkan pada QUADPACK (yang juga berdasarkan GSL), dan memiliki beberapa fitur modern yang rapi, misalnya berdasarkan Eigen, dukungan multiprecision.