NAME¶

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

Synopsis¶

Defined in header <experimental/simd>
template< class T, class Abi, class BinaryOperation =
std::plus<> > (1) (parallelism TS v2)
T reduce( const simd<T, Abi>& v, BinaryOperation binary_op
= {} );
template< class M, class V, class BinaryOperation >

typename V::value_type
reduce( const const_where_expression<M, V>& x, (2) (parallelism TS v2)

typename V::value_type identity_element,
BinaryOperation binary_op = {} );
template< class M, class V >

typename V::value_type (3) (parallelism TS v2)

reduce( const const_where_expression<M, V>& x, std::plus<>
binary_op ) noexcept;
template< class M, class V >

typename V::value_type (4) (parallelism TS v2)

reduce( const const_where_expression<M, V>& x,
std::multiplies<> binary_op ) noexcept;
template< class M, class V >

typename V::value_type (5) (parallelism TS v2)

reduce( const const_where_expression<M, V>& x,
std::bit_and<> binary_op ) noexcept;
template< class M, class V >

typename V::value_type (6) (parallelism TS v2)

reduce( const const_where_expression<M, V>& x,
std::bit_or<> binary_op ) noexcept;
template< class M, class V >

typename V::value_type (7) (parallelism TS v2)

reduce( const const_where_expression<M, V>& x,
std::bit_xor<> binary_op ) noexcept;
template< class T, class Abi > (8) (parallelism TS v2)
T hmin( const simd<T, Abi>& v ) noexcept;
template< class M, class V >

typename V::value_type (9) (parallelism TS v2)

hmin( const const_where_expression<M, V>& x ) noexcept;
template< class T, class Abi > (10) (parallelism TS v2)
T hmax( const simd<T, Abi>& v ) noexcept;
template< class M, class V >

typename V::value_type (11) (parallelism TS v2)

hmax( const const_where_expression<M, V>& x ) noexcept;

1) Reduces all values in v over binary_op.
2) Reduces the values in x where the associated mask element is true over binary_op.
3) Returns the sum of all values in x where the associated mask element is true.
4) Returns the product of all values in x where the associated mask element is true.
5) Returns the aggregation using bitwise-and of all values in x where the associated
mask element is true.
6) Returns the aggregation using bitwise-or of all values in x where the associated
mask element is true.
7) Returns the aggregation using bitwise-xor of all values in x where the associated
mask element is true.
8) Reduces all values in v over std::min.
9) Reduces all values in x where the associated mask element is true over std::min.
10) Reduces all values in v over std::max.
11) Reduces all values in x where the associated mask element is true over std::max.

The behavior is non-deterministic if binary_op is not associative or not
commutative.

Parameters¶

v - the simd vector to apply the reduction to
x - the return value of a where expression to apply the reduction to
a value that acts as identity element for binary_op;
identity_element - binary_op(identity_element, a) == a must hold for all finite a of
type V::value_type
binary FunctionObject that will be applied in unspecified order
binary_op - to arguments of type V::value_type or simd<V::value_type, A>,
with unspecified ABI tag A. binary_op(v, v) must be convertible
to V

Return value¶

The result of operation of the type:

1,8,10) T
2-7,9,11) V::value_type

Example¶

// Run this code

#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);
}

Output:¶

sum of data = 523776

See also¶

reduce similar to std::accumulate, except out of order
(C++17) (function template)