Question

我有一个mainFun，其中包含四个参数x，a，b和c，所有参数都是矢量值且可能有不同的长度。此函数调用计算成本高昂的expensiveFun，因此我希望减少对expensiveFun 的调用次数。需要为x[i]，a[i]，b[i]，c[i]以及a，b或{{}中的每个值调用此函数1}}长度较短，然后需要包裹＃34; （他们的索引是模c）。最好为a[i % a.size()]的每个可能的不同值（即所有整数0，...，max（x））预先计算expensiveFun，然后只填写输出{{1由x提供。如果out，out[i] = precomputedValues[x[i]]和a具有相同的长度（例如下面的代码），则可以轻松实现这一点，但如果不是，则会变得很难看。有没有办法让它在参数向量长度不同的情况下更有效？

下面我提供一个可重复的例子。它是一个简化的代码，仅作为示例编写。

示例输入：

应折叠参数，使其成为：

std::vector<int> expensiveFun(int x, int a, int b, int c) {
  std::vector<int> out(x+1);
  out[0] = a+b*c;
  for (int i = 1; i <= x; i++)
    out[i] = out[i-1] * i + a * (b+c);
  return out;
}

std::vector<int> mainFun(
    std::vector<int> x,
    std::vector<int> a,
    std::vector<int> b,
    std::vector<int> c
) {

  int n = x.size();
  int a_size = a.size();
  int b_size = b.size();
  int c_size = c.size();

  std::vector<int> out(n);

  // easy
  if (a_size == b_size && b_size == a_size) {

    int max_x = 0;
    for (int j = 0; j < n; j++)
      if (x[j] > max_x)
        max_x = x[j];

    for (int i = 0; i < a_size; i++) {
      int max_x = 0;
      for (int j = 0; j < n; j += a_size) {
        if (x[j] > max_x)
          max_x = x[j];
      }
      std::vector<int> precomputedValues = expensiveFun(max_x, a[i], b[i], c[i]);
      for (int j = i; j < n; j += a_size) {
        out[j] = precomputedValues[x[j]];
      }
    }

  // otherwise give up
  } else {

    for (int j = 0; j < n; j++) {
      out[j] = expensiveFun(x[j], a[j % a_size], c[j % c_size], c[j % c_size]).back();
    }

  }

  return out;
}

目前输出并不重要，因为这里的主要问题是有效处理不同大小的参数向量。

Answer 1

Memoize你的职能。

为a，b和c的组合计算向量后，将其存储在std::unordered_map中。下次看到相同的组合时，您将检索已经计算过的向量 - 使用计算机内存进行计算加速的经典方法。

std::map<std::tuple<int,int,int>,std::vector<int>> memo;

int expensiveFunMemo(int x, int xMax, int a, int b, int c) {
  assert(x <= xMax);
  std::vector<int>& out = memo[std::make_tuple(a, b, c)];
  if (!out.size()) {
    out.push_back(a+b*c);
    for (int i = 1; i <= xMax; i++)
      out.push_back(out[i-1] * i + a * (b+c));
  }
  assert(out.size == xMax+1);
  return out[x];
}

这样，您永远不会为expensiveFunMemo的任意组合多次计算{a, b, c}。

您的mainFun也变得更简单了：

std::vector<int> mainFun(
    const std::vector<int>& x,
    const std::vector<int>& a,
    const std::vector<int>& b,
    const std::vector<int>& c
) {
  size_t n = x.size();
  size_t a_size = a.size();
  size_t b_size = b.size();
  size_t c_size = c.size();
  std::vector<int> out(n);
  int xMax = *std::max_element(x.begin(), x.end());
  for (size_t j = 0 ; j < n ; j++) {
    out[j] = expensiveFunMemo(x[j], xMax, a[j % a_size], c[j % c_size], c[j % c_size]);
  }
  return out;
}

注意：此解决方案使用std::map<K,V>而不是std::unordered_map<K,V>，因为std::tuple<...>缺少通用哈希函数。 This Q&A提供了解决此问题的解决方案。

优化对昂贵功能的调用次数

1 个答案: