Namespaces
Variants

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

From cppreference.net
C++
Experimental
Extensions for parallelism v2
SIMD library
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
Definiert in Header <experimental/simd>
template < class T, class Abi, class BinaryOperation = std:: plus <> >
T reduce ( const simd < T, Abi > & v, BinaryOperation binary_op = { } ) ;
(1) (Parallelism 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 Identitätselement, BinaryOperation binäre_Operation = { } ) ;
(2) (Parallelism 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) (Parallelismus TS v2)
template < class M, class V >

typename V :: value_type

reduce ( const const_where_expression < M, V > & x, std:: multiplies <> binäre_Operation ) noexcept ;
(4) (Parallelism 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) (Parallelism 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) (Parallelismus 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) (Parallelism TS v2)
template < class T, class Abi >
T hmin ( const simd < T, Abi > & v ) noexcept ;
(8) (Parallelism TS v2)
template < class M, class V >

typename V :: value_type

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

typename V :: value_type

hmax ( const const_where_expression < M, V > & x ) noexcept ;
(11) (Parallelism TS v2)
1) Reduziert alle Werte in v über binary_op .
2) Reduziert die Werte in x , bei denen das zugehörige Maskenelement true ist, über binary_op .
3) Gibt die Summe aller Werte in x zurück, bei denen das zugehörige Maskenelement true ist.
4) Gibt das Produkt aller Werte in x zurück, bei denen das zugehörige Maskenelement true ist.
5) Gibt die Aggregation mittels bitweiser UND-Verknüpfung aller Werte in x zurück, bei denen das zugehörige Maskenelement true ist.
6) Gibt die Aggregation mittels bitweiser ODER-Verknüpfung aller Werte in x zurück, bei denen das zugehörige Maskenelement true ist.
7) Gibt die Aggregation mittels bitweisem XOR aller Werte in x zurück, bei denen das zugehörige Maskenelement true ist.
8) Reduziert alle Werte in v über std:: min .
9) Reduziert alle Werte in x , bei denen das zugehörige Maskenelement true ist, über std:: min .
10) Reduziert alle Werte in v über std:: max .
11) Reduziert alle Werte in x , bei denen das zugehörige Maskenelement true ist, über std:: max .

Das Verhalten ist nicht deterministisch, wenn binary_op nicht assoziativ oder nicht kommutativ ist.

Inhaltsverzeichnis

Parameter

v - der simd -Vektor, auf den die Reduktion angewendet werden soll
x - der Rückgabewert eines where -Ausdrucks, auf den die Reduktion angewendet werden soll
identity_element - ein Wert, der als Identitätselement für binary_op fungiert; binary_op ( identity_element, a ) == a muss für alle endlichen a des Typs V :: value_type gelten
binary_op - binäres FunctionObject , das in unbestimmter Reihenfolge auf Argumente des Typs V :: value_type oder simd < V :: value_type , A > mit unbestimmtem ABI-Tag A angewendet wird. binary_op ( v, v ) muss in V konvertierbar sein

Rückgabewert

Das Ergebnis der Operation des Typs:

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

Beispiel

Diesen Code ausführen 
#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);
}

Ausgabe: 

sum of data = 523776

Siehe auch

(C++17)
ähnlich wie std::accumulate , jedoch außerhalb der Reihenfolge
(Funktions-Template)