Question

是否有人编写了符合C ++ STL标准的算法，该算法将std::transform和std::accumulate组合成一个单一的算法，支持一元，二元和甚至（n-ary！）变体，比如{{ 1}？我想要这个，因为我发现这种模式在例如线性代数中是高度可重用的，例如在（l1-）范数计算中。 l1-norm计算元素绝对值的总和。

Answer 1

嗯...我敢打赌，你可以通过将转换嵌入二元谓词，转换元素并在转换后累积来实现。

struct times2accumulator {
   int operator()( int oldvalue, int newvalue ) const {
      return oldvalue + 2*newvalue;
   }
};
int r = std::accumulate( v.begin(), v.end(), 2, times2accumulator() );

该仿函数等同于：

struct times2 {
   int operator()( int x ) {
      return 2*x;
   }
};
std::vector<int> tmp; tmp.reserve( v.size() );
std::transform( v.begin(), v.end(), std::back_inserter(tmp), times2 );
int r = std::accumulate( tmp.begin(), tmp.end(), 0 );

当然这可以是通用的，只需将转换函子传递给通用的基础仿函数：

template <typename Transform>
struct transform_accumulator_t {
    Transform t;
    transform_accumulator_t( Transform t ) : t(t) {}
    int operator()( int oldvalue, int newvalue ) const {
        return oldvalue + t(newvalue);
    }
};
// syntactic sugar:
template <typename T>
transform_accumulator_t<T> transform_accumulator( T t ) {
    return transform_accumulator_t<T>(t);
}
int r = std::accumulate(v.begin(), v.end(), 0, transform_accumulator(times2));

您还可以对容器中的类型进行概括...甚至可以创建一个更通用的transform_accumulator，它同时包含累加器和转换函子并按顺序应用它们。实际实施留给读者练习。

Answer 2

虽然它可能不完全符合原始意图，但std::inner_product基本上是您的二进制版本。您传递初始值，两个范围和两个仿函数，并将它们应用为：

T acc = initial_value;
while (begin1 != end1) {
    acc = binary_op1(acc, binary_op2(begin1, begin2);
    ++begin1;
    ++begin2;
return acc;

所以，对于你的L1，你会对这个一般命令做点什么：

norm = std::inner_product(input1.begin(), input1.end(), 
                          input2.begin(), input2.end(), 
                          std::plus<int>(), std::abs);

只有这不起作用 - 现在，它试图通过std::abs你真正需要一个结合了两个输入的二进制函数，但我不确定这两个输入是如何真正的假设要合并。

std::partial_sum非常接近你的一元版本，除了累积结果之外，它（尝试）写出每个中间结果，而不仅仅是最终结果。要获得最终结果，您必须编写（并传递一个实例）一种只包含单个值的do-nothing迭代器：

template<class T, class Dist=size_t, class Ptr = T*, class Ref = T&>
class unique_it : public std::iterator<std::random_access_iterator_tag, T, Dist, Ptr, Ref> { 
   T &value;
public:
   unique_it(T &v) : value(v) {}
   T &operator*() { return value; }
   unique_it &operator++() { return *this; }
   unique_it &operator+(size_t) { return *this; }
   unique_it &operator++(int) { return *this; }
};

template <class T>
unique_it<T> make_res(T &v) { return unique_it<T>(v); }

有了这个，你的L1规范化看起来像这样：

int main(){ 
    double result=0.0;
    double inputs[] = {1, -2, 3, -4, 5, -6};

    std::partial_sum(
        inputs, inputs+6, 
        make_res(result),
        [](double acc, double v) {return acc + std::abs(v);});

    std::cout << result << "\t";
    return 0;
}

Answer 3

如果你想使用一些并行性，我使用OpenMP制作了一个快速版本：

template <class T, 
          class InputIterator, 
          class MapFunction, 
          class ReductionFunction>
T MapReduce_n(InputIterator in, 
              unsigned int size, 
              T baseval, 
              MapFunction mapper, 
              ReductionFunction reducer)
{
    T val = baseval;

    #pragma omp parallel
    {
        T map_val = baseval;

        #pragma omp for nowait
        for (auto i = 0U; i < size; ++i)
        {
            map_val = reducer(map_val, mapper(*(in + i)));
        }

        #pragma omp critical
        val = reducer(val, map_val);
    }

    return val;
}

速度很快，但肯定有优化空间，特别是for (auto i = 0U; i < size; ++i)我认为。（但我无法想象如何使用OpenMP创建一个仅使用迭代器的版本，任何帮助都会受到赞赏！）。

在一个1000000元素数组的快速测试中，计算迭代1000次得到一个平均值，我进行了一些比较。

版本1：

for (auto i = 0U; i < size; ++i)
    val += std::pow(in[i][0], 2) + std::pow(in[i][1], 2);

编译时得分

。

g++：30秒
g++ -O3：2.6秒

版本2：

我认为这个版本对于这个计算是最优化的。（它给出了最好的结果）。

#pragma omp parallel reduction( + : val )
{
    double map_val = 0.0;

    #pragma omp for
    for (int i=0; i < size; ++i)
    {
        map_val += std::pow(in[i][0], 2) + std::pow(in[i][1], 2);
    }

    val += map_val;
}

g++ -O3：0.2秒（这是最好的一个）

版本3

此版本使用前面显示的MapReduce_n函数模板：

double val = MapReduce_n(in, size, 0.0, [] (fftw_complex val)
    {
        return std::pow(val[0], 2.0) + std::pow(val[1], 2.0);
    }, std::plus<double>());

g++ -O3：0.4秒，因此直接使用OMP直接减少会有轻微的开销。但是，它不允许自定义操作员，所以有一点（遗憾的是）你必须以通用性换取速度。

Answer 4

我很惊讶没有人说如何用Boost.Range做这个：

accumulate(v | transformed((int(*)(int))&std::abs), 0);

其中v是Singe Pass Range（即任何STL容器）。必须指定abs重载，否则这将像Haskell一样优雅。

Answer 5

从C ++ 17开始，还有std::transform_reduce，它还有可并行化的优点。

https://en.cppreference.com/w/cpp/algorithm/transform_reduce

变换和累加

5 个答案: