c++17 transform_reduce的使用

std::transform

概念

并行地对一个序列进行变换操作。

定义

#include <algorithm>

// c++17起
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class UnaryOperation >
ForwardIt2 transform( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 d_first, UnaryOperation unary_op );

// c++17起
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt3, class BinaryOperation >
ForwardIt3 transform( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 first2, ForwardIt3 d_first, BinaryOperation binary_op );

参数

参数	含义
policy	策略
first1	要变换的第一个元素
last1	要变换的最后一个元素
first2	要变换的第二元素范围的起始
d_first	目标范围的开始
unary_op	将要应用的一元算符函数。等价于：Ret fun(const Type &a);
binary_op	被使用的二元函数对象。等价于：Ret fun(const Type1 &a, const Type2 &b);

策略

策略	含义
std::execution::seq	调用线程不确定有序(线程内重排)
std::execution::par	多线程调用,线程内(重排),线程间并行.
std::execution::par_unseq	多线程可能向量化,调用间无序,且可能交错.这是放松模式.

源码

// 可能的实现:unary_op
template<class InputIt, class OutputIt, class UnaryOperation>
OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first, 
                   UnaryOperation unary_op)
{
    while (first1 != last1) {
        *d_first++ = unary_op(*first1++);
    }
    return d_first;
}

// 可能的实现: binary_op
template<class InputIt1, class InputIt2, 
         class OutputIt, class BinaryOperation>
OutputIt transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, 
                   OutputIt d_first, BinaryOperation binary_op)
{
    while (first1 != last1) {
        *d_first++ = binary_op(*first1++, *first2++);
    }
    return d_first;
}

示例

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
	std::vector<int> src{ 1,2,3,4,5,6,7,8 };

	std::vector<int> result(src.size());
	std::transform(std::execution::par, src.begin(), src.end(), result.begin(), [](int x) 	  {
		return x * 2;
	});

	for (auto it : result)
		cout << it << endl;

	system("pause");
	return 0;
}

执行结果：

2
4
6
8
10
12
14
16

std::transform_reduce

概念

并行地对一个序列进行变换操作并求和。

定义

#include <execution>

// c++17起
template<class ExecutionPolicy,
         class ForwardIt1, class ForwardIt2, class T>
T transform_reduce(ExecutionPolicy&& policy,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, T init);

// c++17起
template<class ExecutionPolicy,
         class ForwardIt1, class ForwardIt2, class T, class BinaryOp1, class BinaryOp2>
T transform_reduce(ExecutionPolicy&& policy,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2,
                   T init, BinaryOp1 binary_op1, BinaryOp2 binary_op2);

// c++17起
template<class ExecutionPolicy,
         class ForwardIt, class T, class BinaryOp, class UnaryOp>
T transform_reduce(ExecutionPolicy&& policy,
                   ForwardIt first, ForwardIt last,
                   T init, BinaryOp binary_op, UnaryOp unary_op);

参数

参数	含义
policy	策略
first	变换并求和的第一个元素
last	变换并求和的最后一个元素
init	广义和的初始值
unary_op	将要应用的一元算符函数。
binary_op	被使用的二元函数对象。

示例

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
	std::vector<int> src{ 1,2,3,4,5,6,7,8 };

	// 并行转换并求和 --- 将src中每个元素乘以2并累加求和
	int sum = std::transform_reduce(std::execution::par, src.begin(), src.end(), 0, std::plus<int>{}, [](int x) {
		return x * 2;
		});

	cout << "sum: " << sum << endl;

	system("pause");
	return 0;
}

执行结果：

sum: 72

std::reduce

概念

并行求和

定义

#include <<numeric>>

// c++17起
template<class ExecutionPolicy, class ForwardIt>
typename std::iterator_traits<ForwardIt>::value_type reduce(
    ExecutionPolicy&& policy,
    ForwardIt first, ForwardIt last);

// c++17起
template<class ExecutionPolicy, class ForwardIt, class T>
T reduce(ExecutionPolicy&& policy,
         ForwardIt first, ForwardIt last, T init);

// c++17起
template<class ExecutionPolicy, class ForwardIt, class T, class BinaryOp>
T reduce(ExecutionPolicy&& policy,
         ForwardIt first, ForwardIt last, T init, BinaryOp binary_op);

参数

参数	含义
policy	策略
first，last	元素范围
init	广义和的初始值
binary_op	二元操作符

示例

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
	std::vector<int> src{ 1,2,3,4,5,6,7,8 };

	// 并行求和
	int sum1 = std::reduce(std::execution::par, src.begin(), src.end());
	cout << "sum1: " << sum1 << endl;

	system("pause");
	return 0;
}

执行结果：

36

std::inclusive_scan

概念

并行地对一个序列进行前缀和。

定义

#include <numeric>

// c++17起
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardtIt2 inclusive_scan( ExecutionPolicy&& policy, ForwardIt1 first,
                            ForwardIt1 last, ForwardIt2 d_first );

// c++17起
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class BinaryOperation >
ForwardIt2 inclusive_scan( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,
                           ForwardIt2 d_first, BinaryOperation binary_op );

// c++17起
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class BinaryOperation, class T >
ForwardIt2 inclusive_scan( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
                           BinaryOperation binary_op, T init );

参数

参数	含义
policy	策略
first，last	元素范围
d_first	目标范围的起始
init	广义和的初始值
binary_op	二元操作符

示例

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
	std::vector<int> src{ 1,2,3,4,5,6,7,8 };

	// 并行前缀和
	std::vector<int> result1(src.size());
	std::inclusive_scan(std::execution::par, src.begin(), src.end(), result1.begin());

	for (auto it : result)
		cout << it << endl;

	system("pause");
	return 0;
}

执行结果：

2
4
6
8
10
12
14
16