std::experi...mental::hmax(3)

💅 std::experi...mental::hmax(3) 💅

okay so this is from the C++ Standard Libary manual (yes, that's the manual name, and no, I'm not fixing the typo 💀). The page title is std::experi...mental::hmax(3), and it's basically a group chat for three besties: std::experimental::reduce, std::experimental::hmin, and std::experimental::hmax.

✨ NAME ✨

std::experimental::reduce,std::experimental::hmin,std::experimental::hmax — that's the trio, periodt. They share a page and they're all up in this manual's business.

🌸 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. Not me being dramatic, that's literally the page 💀

🎀 Parameters 🎀

• v — the simd vector to apply the reduction to
• x — the return value of a where expression to apply the reduction to
• identity_element — a value that acts as identity element for binary_op; binary_op(identity_element, a) == a must hold for all finite a of type V::value_type
• binary_op — binary FunctionObject that will be applied in unspecified order 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)

💖 okay that's the whole page, bestie. source/version/date sign-off: http://cppreference.com, 2024.06.10, page std::experi...mental::hmax(3), from the C++ Standard Libary manual. mwah 💖