Question

长时间浏览器，第一次问问者。我编写了许多用于执行各种一维数值积分方法的脚本，并将它们编译成一个库。我希望该库能够尽可能灵活地集成它。

这里我包含一个例子：一个非常简单的梯形规则示例，我将指针传递给要集成的函数。

// Numerically integrate (*f) from a to b
// using the trapezoidal rule.
double trap(double (*f)(double), double a, double b) {
  int N = 10000;
  double step = (b-a)/N;
  double s = 0;
  for (int i=0; i<=N; i++) {
    double xi = a + i*step;
    if (i == 0 || i == N) { s += (*f)(xi); }
    else { s += 2*(*f)(xi); }
  }
  s *= (b-a)/(2*N);
  return s;
}

这对于只接受一个参数的简单函数非常有用。例如：

double a = trap(sin,0,1);

然而，有时候我可能想要整合具有更多参数的东西，比如二次多项式。在该示例中，系数将在集成之前由用户定义。示例代码：

// arbitrary quadratic polynomial
double quad(double A, double B, double C, double x) {
  return (A*pow(x,2) + B*x + C);
}

理想情况下，我可以做这样的事情来整合它：

double b = trap(quad(1,2,3),0,1);

但显然这不起作用。我通过定义一个将系数作为成员和感兴趣的函数作为成员函数的类来解决这个问题：

class Model {
  double A,B,C;
public:
  Model() { A = 0; B = 0; C = 0; }
  Model(double x, double y, double z) { A = x; B = y; C = z; }
  double func(double x) { return (A*pow(x,2)+B*x+C); }
};

然而，我的集成函数需要更改为将对象作为输入而不是函数指针：

// Numerically integrate model.func from a to b
// using the trapezoidal rule.
double trap(Model poly, double a, double b) {
  int N = 10000;
  double step = (b-a)/N;
  double s = 0;
  for (int i=0; i<=N; i++) {
    double xi = a + i*step;
    if (i == 0 || i == N) { s += poly.func(xi); }
    else { s += 2*poly.func(xi); }
  }
  s *= (b-a)/(2*N);
  return s;
}

这很好用，但是生成的库不是很独立，因为它需要在某个地方定义类Model。此外，理想情况下，模型应该能够从用户更改为用户，因此我不想在头文件中修复它。我试图使用函数模板和仿函数来使其工作，但它不是非常独立，因为再次，模板应该在头文件中定义（除非你想显式实例化，我不这样做。）

所以，总结一下：有什么方法可以让我的集成函数接受具有可变数量输入参数的任意1D函数，同时仍然保持足够独立，以便可以将它们编译成独立的库？提前感谢您的建议。

Answer 1

如果你买不起C ++ 11，你需要的是模板和std::bind()（或其boost::bind()对应物）。例如，这就是您的trap()函数将成为：

template<typename F>
double trap(F&& f, double a, double b) {
  int N = 10000;
  double step = (b-a)/N;
  double s = 0;
  for (int i=0; i<=N; i++) {
    double xi = a + i*step;
    if (i == 0 || i == N) { s += f(xi); }
//                               ^
    else { s += 2* f(xi); }
//                 ^
  }
  s *= (b-a)/(2*N);
  return s;
}

注意，我们从函数指针推广并允许传入任何类型的可调用对象（例如包括C ++ 11 lambda）。因此，调用它的语法用户提供的函数不是*f(param)（仅适用于函数指针），而只是f(param)。

关于灵活性，让我们考虑两个硬编码功能（并假装它们有意义）：

double foo(double x)
{
    return x * 2;
}

double bar(double x, double y, double z, double t)
{
    return x + y * (z - t);
}

现在，您可以直接在trap()的输入中提供第一个函数，或者将第二个函数的最后三个参数绑定到某个特定值的结果（您可以自由选择要绑定的参数）：

#include <functional>

int main()
{
    trap(foo, 0, 42);
    trap(std::bind(bar, std::placeholders::_1, 42, 1729, 0), 0, 42);
}

当然，使用lambdas可以获得更大的灵活性：

#include <functional>
#include <iostream>

int main()
{
    trap(foo, 0, 42);
    trap(std::bind(bar, std::placeholders::_1, 42, 1729, 0), 0, 42);

    int x = 1729; // Or the result of some computation...
    int y = 42; // Or some particular state information...
    trap([&] (double d) -> double
    {
        x += 42 * d; // Or some meaningful computation...
        y = 1; // Or some meaningful operation...
        return x;
    }, 0, 42);

    std::cout << y; // Prints 1
}

你也可以传递你自己的有状态函子tp trap()，或者包含在std::function对象中的一些可调用对象（如果你买不起C ++ 11，可以传递boost::function）。选择范围很广。

这是live example。

Answer 2

你要做的是使这成为可能

trap( quad, 1, 2, 3, 0, 1 );

使用C ++ 11，我们有别名模板和可变参数模板

template< typename... Ts >
using custom_function_t = double (*f) ( double, Ts... );

上面定义了一个custom_function_t，它带有两个可变数量的参数。

因此您的trap功能变为

template< typename... Ts >
double trap( custom_function_t<Ts...> f, Ts... args, double a, double b ) {
    int N = 10000;
    double step = (b-a)/N;
    double s = 0;
    for (int i=0; i<=N; i++) {
        double xi = a + i*step;
        if (i == 0 || i == N) { s += f(xi, args...); }
        else { s += 2*f(xi, args...); }
    }
    s *= (b-a)/(2*N);
    return s;
}

用法：

double foo ( double X ) {
  return X;
}

double quad( double X, double A, double B, double C ) {
  return(A*pow(x,2) + B*x + C);
}

int main() {
  double result_foo  = trap( foo, 0, 1 );
  double result_quad = trap( quad, 1, 2, 3, 0, 1 );  // 1, 2, 3 == A, B, C respectively
}

在Apple LLVM 4.2编译器上测试。

C ++：使用任意数量的参数传递函数作为参数

2 个答案: