std::experimental::reduce, std::experimental::hmin, std::experimental::hmax

 

C++

编译器支持

自由（freestanding）与宿主（hosted）

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (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 图形

 

并行扩展 v2

并行异常
exception_list
附加执行策略
execution::vector_policy	execution::unsequenced_policy
算法
归纳 归约归约加归约减归约乘	归约位与归约位或归约位异或归约最小归约最大	for_loopfor_loop_stridedfor_loop_nfor_loop_n_strided
execution::no_vec
execution::ordered_update_t
任务块
task_block
task_cancelled_exception
define_task_blockdefine_task_block_restore_thread
数据并行向量

 

SIMD 库

主要类
simd	simd_mask
ABI 标签
simd_abi::scalar simd_abi::fixed_size	simd_abi::native simd_abi::compatible	simd_abi::max_fixed_size simd_abi::deduce
对齐标签
element_aligned_tagelement_aligned	vector_aligned_tagvector_aligned	overaligned_tagoveraligned
Where 表达式
其中	where_expression	const_where_expression
类型转换
simd_caststatic_simd_cast	to_fixed_sizeto_compatibleto_native	splitsplit_by concat
算法
min max	minmax clamp
归约
reducehminhmax
掩码归约
all_ofany_ofnone_ofsome_of	popcount find_first_setfind_last_set
特性
is_simdis_simd_mask is_abi_tag is_simd_flag_type	simd_size memory_alignment rebind_simdresize_simd
数学函数

 

定义于头文件 <experimental/simd>
template< class T, class Abi, class BinaryOperation = std::plus<> > T reduce( const simd<T, Abi>& v, BinaryOperation binary_op = {} );	(1)	(并行技术规范 v2)
template< class M, class V, class BinaryOperation > typename V::value_type reduce( const const_where_expression<M, V>& x,         typename V::value_type identity_element, BinaryOperation binary_op = {} );	(2)	(并行技术规范 v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::plus<> binary_op ) noexcept;	(3)	(并行技术规范 v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::multiplies<> binary_op ) noexcept;	(4)	(并行技术规范 v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::bit_and<> binary_op ) noexcept;	(5)	(并行技术规范 v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::bit_or<> binary_op ) noexcept;	(6)	(并行技术规范 v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::bit_xor<> binary_op ) noexcept;	(7)	(并行技术规范 v2)
template< class T, class Abi > T hmin( const simd<T, Abi>& v ) noexcept;	(8)	(并行技术规范 v2)
template< class M, class V > typename V::value_type hmin( const const_where_expression<M, V>& x ) noexcept;	(9)	(并行技术规范 v2)
template< class T, class Abi > T hmax( const simd<T, Abi>& v ) noexcept;	(10)	(并行技术规范 v2)
template< class M, class V > typename V::value_type hmax( const const_where_expression<M, V>& x ) noexcept;	(11)	(并行技术规范 v2)

1) 对 v 中的所有值执行 binary_op 归约。

2) 对 x 中关联掩码元素为 true 的值执行 binary_op 归约。

3) 返回 x 中关联掩码元素为 true 的所有值的和。

4) 返回 x 中关联掩码元素为 true 的所有值的积。

5) 返回 x 中关联掩码元素为 true 的所有值通过按位与运算的聚合结果。

6) 返回 x 中关联掩码元素为 true 的所有值通过按位或运算的聚合结果。

7) 返回 x 中关联掩码元素为 true 的所有值通过按位异或运算的聚合结果。

8) 对 v 中的所有值执行 std::min 归约。

9) 对 x 中关联掩码元素为 true 的所有值执行 std::min 归约。

10) 对 v 中的所有值执行 std::max 归约。

11) 对 x 中关联掩码元素为 true 的所有值执行 std::max 归约。

如果 binary_op 不满足结合律或交换律，则行为不确定。

参数

v	-	要应用归约的 simd 向量
x	-	要应用归约的 where 表达式的返回值
identity_element	-	对 binary_op 起标识元素作用的值；对于类型为 V::value_type 的所有有限 a，必须满足 binary_op(identity_element, a) == a
binary_op	-	二元 函数对象，将以未指定顺序应用于类型为 V::value_type 或 simd<V::value_type, A> 的参数，其中 ABI 标签 A 未指定。binary_op(v, v) 必须可转换为 V

返回值

操作的结果，类型为

1,8,10) T

2-7,9,11) V::value_type

示例

运行此代码

#include <array>
#include <cassert>
#include <cstddef>
#include <experimental/simd>
#include <functional>
#include <iostream>
#include <numeric>
namespace stdx = std::experimental;
 
int main()
{
    using V = stdx::native_simd<double>;
 
    alignas(stdx::memory_alignment_v<V>) std::array<V::value_type, 1024> data;
    std::iota(data.begin(), data.end(), 0);
 
    V::value_type acc{};
    for (std::size_t i = 0; i < data.size(); i += V::size())
        acc += stdx::reduce(V(&data[i], stdx::vector_aligned), std::plus{});
    std::cout << "sum of data = " << acc << '\n';
 
    using W = stdx::fixed_size_simd<int, 4>;
    alignas(stdx::memory_alignment_v<W>) std::array<int, 4> arr{2, 5, 4, 1};
    auto w = W(&arr[0], stdx::vector_aligned);
    assert(stdx::hmin(w) == 1 and stdx::hmax(w) == 5);
}

输出

sum of data = 523776

参阅

reduce (C++17)

类似于 std::accumulate，但顺序是乱序的 (函数模板)