Question

学习目的：

我正在创建一个小的数值方法库，我正在尝试实现渐变，目前我已经完成了2D渐变和3D渐变。但我想将其概括为更高的维度。

目前我有：

matrix<double> analysis::gradient_2D(std::function<double(double, double)> fn, double x, double y)
{
    matrix<double> R(2, 1);

    std::function<double(double)> fnX = [fn, y](double xVar){ return fn(xVar, y); };
    std::function<double(double)> fnY = [fn, x](double yVar){ return fn(x, yVar); };

    R(1, 1) = differentiateBest(fnX, x);
    R(1, 2) = differentiateBest(fnY, y);

    return R;
}

matrix<double> analysis::gradient_3D(std::function<double(double, double, double)> fn, double x, double y, double z)
{
    matrix<double> R(3, 1);

    std::function<double(double)> fnX = [fn, y, z](double xVar){ return fn(xVar, y,z); };
    std::function<double(double)> fnY = [fn, x, z](double yVar){ return fn(x ,yVar, z); };
    std::function<double(double)> fnZ = [fn, x, y](double zVar){ return fn(x, y, zVar); };

    R(1, 1) = differentiateBest(fnX, x);
    R(1, 2) = differentiateBest(fnY, y);
    R(1, 3) = differentiateBest(fnZ, z);

    return R;
}

// Where 

double analysis::differentiateBest(std::function<double(double)> fn, double x)
{
    return derivative_1_Richardson_6O(fn,  x);
}
// For brevity , derivative_1_Richardson_6O also has the same input as differentiateBest

我知道它很冗长，但我喜欢它

问题我想做的是创建一个

// What do I do at the ...  ? 
matrix<double> analysis::gradient_ND(std::function<double(...)> fn, matrix<double>)

这样我就可以传递一个带有任意输入的std :: function N，我将通过具有N个值的向量。

我将如何做到这一点？如果答案太长，链接也会受到赞赏。谢谢。

PS：我看到了一个使用模板的方法，但如果我在实现中使用模板，我将不得不将.cpp文件更改为其他内容吗？我想避免。如果使用模板是唯一的方法，那么我将不得不妥协。谢谢。

Answer 1

template<class T>
struct array_view {
  T* b = nullptr; T* e = nullptr;
  T* begin() const { return b; }
  T* end() const { return e; }

  size_t size() const { return end()-begin(); }
  bool empty() const { return begin()==end(); }
  T& front()const{return *begin(); }
  T& back()const{return *std::prev(end()); }

  T& operator[](size_t i)const{return begin()[i]; }

  array_view( T* s, T* f ):b(s),e(f) {};
  array_view() = default;

  array_view( T* s, size_t l ):array_view(s, s+l) {}

  using non_const_T = std::remove_const_t<T>;
  array_view( std::initializer_list<non_const_T> il ):
    array_view(il.begin(), il.end()) {}
  template<size_t N>
  array_view( T(&arr)[N] ):array_view(arr, N){}
  template<size_t N>
  array_view( std::array<T,N>&arr ):array_view(arr.data(), N){}
  template<size_t N>
  array_view( std::array<non_const_T,N> const&arr ):
    array_view(arr.data(), N){}
  template<class A>
  array_view( std::vector<T,A>& v):
    array_view(v.data(), v.size()){}
  template<class A>
  array_view( std::vector<non_const_T,A> const& v):
    array_view(v.data(), v.size()){}
};

array_view是对T的连续数组的非拥有视图。它具有来自无数连续容器的转换构造函数（如果matrix是连续的，则应编写转换为array_view）。

然后：

matrix<double> analysis::gradient_ND(std::function<double(array_view<const double>)>, array_view<const double> pt)

是合理的。

使用array_view会导致.h和.cpp代码拆分没有问题。所涉及的唯一模板是固定的（array_view本身），或在构建array_view时解析。

matrix<double> R(pt.size(), 1);

auto make_tmp = [pt]{
  std::vector<double> tmp;
  tmp.reserve(pt.size());
  for (double x:pt)
    tmp.push_back(x);
  return tmp;
};

std::vector<std::function<double(double)>> partials;
partials.reserve(pt.size());
for (size_t i = 0; i < pt.size(); ++i) {
  partials.push_back(
    [&,i](double x){ auto tmp=make_tmp(); tmp[i]=x; return fn(tmp); };
  );
}
for (size_t i = 0; i < pt.size(); ++i) {
  R(1, i) = differentiateBest(partials[i], pt[i]);
}

return R;

请注意，实际上并不需要创建partials数组。你可以直接differentiateBest。

partials重新分配每个呼叫的效率很低。如果您可以使重入不起作用（通常可以正常），创建tmp并按值捕获它，并在每次调用fn后修改和恢复它“将提高性能。

  [&,i,tmp=make_tmp()](double x){ std::swap(tmp[i],x); double r=fn(tmp); std::swap(tmp[i],x); return r; };

是C ++ 14版本。 C ++ 11版本将创建一个tmp变量并按值捕获它。

接受带有任意输入的std :: function作为输入w / o模板

1 个答案: