Thư viện C ++ để tích hợp số (cầu phương)

Tôi có chương trình con nhỏ của riêng mình để tích hợp số (bậc hai), đó là bản chuyển thể C ++ của chương trình ALGOL do Bulirsch & Stoer xuất bản năm 1967 (Numerische Mathematik, 9, 271-278).

Tôi muốn nâng cấp lên một thuật toán (thích ứng) hiện đại hơn và tự hỏi liệu có thư viện C ++ nào (miễn phí) cung cấp như vậy không. Tôi đã có một cái nhìn như GSL (là C), nhưng nó đi kèm với một API khủng khiếp (mặc dù số có thể tốt). Có gì khác?

Một API hữu ích sẽ trông như thế này:

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

Hãy nhìn vào Odeint . Nó hiện là một phần của Boost và nó bao gồm thuật toán Bulirsch-Stoer trong số các thuật toán khác. Để bắt đầu, bạn có thể thấy ở đây một ví dụ rất đơn giản.

MFEM [1] có các hàm bậc hai dễ sử dụng (cả cho các yếu tố bề mặt và thể tích). Chúng tôi đã có thể sử dụng chúng cho các nhiệm vụ khác nhau.

[1] http://mfem.org/

Bạn có thể dễ dàng viết một trình bao bọc C ++ mỏng xung quanh các hàm bậc hai GSL. Các nhu cầu sau 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';
}

Đầu ra

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

Tôi đã thành công với thư viện Cubature (mặc dù nó được viết bằng C). Nó nhằm mục đích tích hợp đa chiều với số lượng kích thước tương đối thấp.

Các thư viện HIntLib được viết bằng C ++ và nó có thói quen cho cầu phương thích nghi (cubature).

Hãy xem https://github.com/tbs1980/NumericalIntegration . Nó dựa trên QUADPACK (mà GSL cũng dựa trên) và có một số tính năng hiện đại gọn gàng, ví dụ dựa trên Eigen, hỗ trợ đa điểm.