std::experimental::parallel::transform_reduce

 

C++

编译器支持

独立和宿主

语言

标准库

标准库头文件

命名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

实验性

技术规范

文件系统库 (文件系统 TS)

库基础 (库基础 TS)

库基础 2 (库基础 TS v2)

库基础 3 (库基础 TS v3)

并行扩展 (并行 TS)

并行扩展 2 (并行 TS v2)

并发扩展 (并发 TS)

并发扩展 2 (并发 TS v2)

概念 (概念 TS)

范围 (范围 TS)

反射 (反射 TS)

数学特殊函数 (特殊函数 TR)

实验性非 TS

模式匹配

线性代数

std::execution

契约

2D 图形

 

并行扩展

执行策略

parallel::execution_policy

parallel::sequential_execution_policyparallel::parallel_execution_policyparallel::parallel_vector_execution_policy

parallel::seqparallel::parparallel::par_vec

并行算法

并行异常

parallel::exception_list

现有算法的并行化版本

新算法

parallel::for_eachparallel::for_each_n

parallel::reduce

parallel::exclusive_scan

parallel::inclusive_scan

parallel::transform_reduce

parallel::transform_exclusive_scan

parallel::transform_inclusive_scan

 

定义在头文件 <experimental/numeric> 中
template< class InputIt, class UnaryOp, class T, class BinaryOp > T transform_reduce( InputIt first, InputIt last,                     UnaryOp unary_op, T init, BinaryOp binary_op );	(1)	(并行 TS)
template< class ExecutionPolicy,           class InputIt, class UnaryOp, class T, class BinaryOp > T transform_reduce( ExecutionPolicy&& policy,                     InputIt first, InputIt last,                     UnaryOp unary_op, T init, BinaryOp binary_op );	(2)	(并行 TS)

将 unary_op 应用于范围 [first, last) 中的每个元素，并使用初始值 init 对结果（可能以未指定的顺序排列和聚合）进行归约，归约运算由 binary_op 完成。

如果 binary_op 不是结合的或非交换的，则行为是不确定的。

如果 unary_op 或 binary_op 修改了 [first, last) 中的任何元素或使其中的任何迭代器失效，则行为是未定义的。

参数

first, last	-	要应用算法的元素范围
init	-	广义和的初始值
policy	-	the 执行策略
unary_op	-	一元 函数对象，将应用于输入范围中的每个元素。返回类型必须可作为 binary_op 的输入
binary_op	-	二元 函数对象，将以未指定的顺序应用于 unary_op 的结果、其他 binary_op 的结果和 init
类型要求
- InputIt 必须满足 遗留输入迭代器 的要求。

返回值

init 和 unary_op(*first)、unary_op(*(first + 1))、... unary_op(*(last - 1)) 关于 binary_op 的广义和，其中广义和 GSUM(op, a
1, ..., a
N) 定义如下

• 如果 N = 1，则为 a
  1，
• 如果 N > 1，则为 op(GSUM(op, b
  1, ..., b
  K), GSUM(op, b
  M, ..., b
  N))，其中

• b
  1, ..., b
  N 可以是 a1, ..., aN 的任何排列，并且
• 1 < K + 1 = M ≤ N

换句话说，unary_op 的结果可以以任意顺序分组和排列。

复杂度

O(last - first) 次 unary_op 和 binary_op 的应用。

异常

• 如果作为算法的一部分调用的函数执行时抛出异常，

• 如果 policy 是 parallel_vector_execution_policy，则调用 std::terminate。
• 如果 policy 是 sequential_execution_policy 或 parallel_execution_policy，则算法退出，并返回一个包含所有未捕获异常的 exception_list。如果只有一个未捕获异常，则算法可能会在不将其包装在 exception_list 中的情况下重新抛出该异常。在遇到第一个异常后，算法在返回之前将执行多少工作是未指定的。
• 如果 policy 是其他类型，则行为是实现定义的。

• 如果算法无法分配内存（无论是自身内存还是处理用户异常时构建 exception_list 所需的内存），则会抛出 std::bad_alloc。

注释

unary_op 不会应用于 init。

如果范围为空，则会返回未修改的 init。

• 如果 policy 是 sequential_execution_policy 的实例，则所有操作都在调用线程中执行。
• 如果 policy 是 parallel_execution_policy 的实例，则操作可以在未指定的线程数量中执行，并且这些线程的执行顺序是未确定的。
• 如果 policy 是 parallel_vector_execution_policy 的实例，则执行可以并行化和矢量化：函数体边界不受尊重，用户代码可以以任意方式重叠和组合（特别是，这意味着用户提供的 Callable 绝不能获取互斥锁来访问共享资源）。

示例

transform_reduce 可用于并行化 std::inner_product

运行此代码

#include <boost/iterator/zip_iterator.hpp>
#include <boost/tuple.hpp>
#include <experimental/execution_policy>
#include <experimental/numeric>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
 
int main()
{
    std::vector<double> xvalues(10007, 1.0), yvalues(10007, 1.0);
 
    double result = std::experimental::parallel::transform_reduce(
        std::experimental::parallel::par,
        boost::iterators::make_zip_iterator(
            boost::make_tuple(std::begin(xvalues), std::begin(yvalues))),
        boost::iterators::make_zip_iterator(
            boost::make_tuple(std::end(xvalues), std::end(yvalues))),
        [](auto r) { return boost::get<0>(r) * boost::get<1>(r); }
        0.0,
        std::plus<>()
    );
    std::cout << result << '\n';
}

输出

10007

另请参见

accumulate	累加或折叠元素范围 (函数模板)
transform	将函数应用于元素范围，并将结果存储在目标范围内 (函数模板)
reduce (并行 TS)	类似于 std::accumulate，但顺序不同 (函数模板)