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

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (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
算法
induction reductionreduction_plusreduction_minusreduction_multiplies	reduction_bit_andreduction_bit_orreduction_bit_xorreduction_minreduction_max	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	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)	(并行 TS 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)	(并行 TS v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::plus<> binary_op ) noexcept;	(3)	(并行 TS v2)
template< class M, class V > typename V::value_type reduce( const const_where_expression<M, V>& x, std::multiplies<> binary_op ) noexcept;	(4)	(并行 TS 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)	(并行 TS 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)	(并行 TS 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)	(并行 TS v2)
template< class T, class Abi > T hmin( const simd<T, Abi>& v ) noexcept;	(8)	(并行 TS v2)
template< class M, class V > typename V::value_type hmin( const const_where_expression<M, V>& x ) noexcept;	(9)	(并行 TS v2)
template< class T, class Abi > T hmax( const simd<T, Abi>& v ) noexcept;	(10)	(并行 TS v2)
template< class M, class V > typename V::value_type hmax( const const_where_expression<M, V>& x ) noexcept;	(11)	(并行 TS v2)

1) 在 binary_op 上归约 v 中的所有者。

2) 在 binary_op 上归约 x 中关联掩码元素为 true 的所有值。

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

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

5) 返回对 x 中关联掩码为 true 的所有值使用按位与的聚合。

6) 返回对 x 中关联掩码为 true 的所有值使用按位或的聚合。

7) 返回对 x 中关联掩码为 true 的所有值使用按位异或的聚合。

8) 在 std::min 上归约 v 中的所有者。

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

10) 在 std::max 上归约 v 中的所有者。

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

如果 binary_op 并无结合性或交换性，则其行为不确定。

参数

v	-	要运用归约的 simd 向量
x	-	要运用归约的 where 表达式的返回值
identity_element	-	对于 binary_op 表现为相同元素的值；binary_op(identity_element, a) == a 必须持有类型 V::value_type 的所有有穷值
binary_op	-	以未指明的 ABI 标签 A，以未指明的顺序，运用于 V::value_type 或 simd<V::value_type, A> 类型的实参的二元 函数对象 (FunctionObject) 。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，但不依序执行 (函数模板)