ไลบรารี C ++ สำหรับการรวมตัวเลข (การสร้างพื้นที่สี่เหลี่ยมจัตุรัส)

ฉันมีรูทีนย่อยเล็ก ๆ ของตัวเองสำหรับการรวมเชิงตัวเลข (การสร้างพื้นที่สี่เหลี่ยมจัตุรัส) ซึ่งเป็นการดัดแปลง C ++ ของโปรแกรม ALGOL ที่เผยแพร่โดย Bulirsch & Stoer ในปี 1967 (Numerische Mathematik, 9, 271-278)

ฉันต้องการอัปเกรดเป็นอัลกอริทึม (ปรับตัว) ที่ทันสมัยกว่าและสงสัยว่ามีไลบรารี่ C ++ ใด ๆ ที่ให้บริการดังกล่าวหรือไม่ ฉันดูเป็น GSL (ซึ่งเป็น C) แต่นั่นมาพร้อมกับ API ที่น่ากลัว (แม้ว่าตัวเลขอาจจะดี) มีอะไรอีกไหม?

API ที่มีประโยชน์จะมีลักษณะดังนี้:

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 ตอนนี้เป็นส่วนหนึ่งของ Boost และมีอัลกอริทึม Bulirsch-Stoer ในการเริ่มต้นที่คุณสามารถดูที่นี่เป็นตัวอย่างที่ง่ายมาก

MFEM [1] มีฟังก์ชั่นการสร้างพื้นที่สี่เหลี่ยมจัตุรัสที่ง่ายต่อการใช้งาน (ทั้งสำหรับองค์ประกอบการโต้คลื่นและปริมาตร) เราสามารถใช้พวกเขาสำหรับงานต่างๆ

[1] http://mfem.org/

คุณสามารถเขียน wrapper C ++ แบบบาง ๆ รอบ ๆ ฟังก์ชันการสร้างพื้นที่สี่เหลี่ยมจัตุรัส GSL ได้อย่างง่ายดาย ความต้องการต่อไปนี้ของ 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';
}

เอาท์พุต

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

ฉันประสบความสำเร็จกับห้องสมุด Cubature (เขียนด้วยภาษา C) มันมีจุดมุ่งหมายเพื่อบูรณาการหลายมิติที่มีจำนวนค่อนข้างต่ำ

ห้องสมุด HIntLibถูกเขียนใน C ++ และมีการปฏิบัติสำหรับการสร้างพื้นที่สี่เหลี่ยมจัตุรัสการปรับตัว (cubature)

ตรวจสอบhttps://github.com/tbs1980/NumericalIntegration มันขึ้นอยู่กับ QUADPACK (ซึ่ง GSL ยังเป็นไปตาม) และมีคุณสมบัติที่ทันสมัยบางอย่างเช่นบนพื้นฐานของ Eigen, การสนับสนุนหลายที่