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

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)	(Parallelismus 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)	(Parallelismus 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<> binary_op ) noexcept;	(4)	(Parallelismus 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)	(Parallelismus 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)	(Parallelismus TS v2)
template< class T, class Abi > T hmin( const simd<T, Abi>& v ) noexcept;	(8)	(Parallelismus TS v2)
template< class M, class V > typename V::value_type hmin( const const_where_expression<M, V>& x ) noexcept;	(9)	(Parallelismus TS v2)
template< class T, class Abi > T hmax( const simd<T, Abi>& v ) noexcept;	(10)	(Parallelismus TS v2)
template< class M, class V > typename V::value_type hmax( const const_where_expression<M, V>& x ) noexcept;	(11)	(Parallelismus 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 bitweisem UND aller Werte in x zurück, bei denen das zugehörige Maskenelement true ist.

6) Gibt die Aggregation mittels bitweisem ODER 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.

[edit] 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 neutrales Element für binary_op fungiert; binary_op(identity_element, a) == a muss für alle endlichen a vom Typ V::value_type gelten
binary_op	-	binäre FunctionObject, die in nicht spezifizierter Reihenfolge auf Argumente vom Typ V::value_type oder simd<V::value_type, A> mit einem nicht spezifizierten ABI-Tag `A` angewendet wird. binary_op(v, v) muss in `V` konvertierbar sein

[edit] Rückgabewert

Das Ergebnis der Operation vom Typ

1,8,10) T

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

[edit] Beispiel

Führen Sie diesen Code aus

#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

[edit] Siehe auch

reduce

(C++17)

ähnlich wie std::accumulate, aber nicht-sequenziell
(Funktionstemplate) [bearbeiten]

Compiler-Unterstützung
Freestanding und gehostet
Sprache
Standardbibliothek
Header der Standardbibliothek
Benannte Anforderungen
Feature-Test-Makros (C++20)
Bibliothek für Sprachunterstützung
Konzepte-Bibliothek (C++20)
Diagnostik-Bibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogramme-Bibliothek
Container-Bibliothek
Iterator-Bibliothek
Ranges-Bibliothek (C++20)
Algorithmen-Bibliothek
Bibliothek für Zeichenketten
Textverarbeitungsbibliothek
Numerik-Bibliothek
Datums- und Zeitbibliothek
Ein-/Ausgabe-Bibliothek
Dateisystembibliothek (C++17)
Unterstützung für nebenläufige Programmierung (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

Technische Spezifikation
Dateisystembibliothek (Filesystem TS)
Grundlagen der Bibliothek (Library Fundamentals TS)
Grundlagen der Bibliothek 2 (Library Fundamentals TS v2)
Grundlagen der Bibliothek 3 (Library Fundamentals TS v3)
Erweiterungen für Parallelität (Parallelism TS)
Erweiterungen für Parallelität 2 (Parallelism TS v2)
Erweiterungen für Nebenläufigkeit (Concurrency TS)
Erweiterungen für Nebenläufigkeit 2 (Concurrency TS v2)
Konzepte (Concepts TS)
Bereiche (Ranges TS)
Reflektion (Reflection TS)
Mathematische Spezialfunktionen (Special Functions TR)
Experimentell Nicht-TS
Pattern Matching
Lineare Algebra
std::execution
Verträge
2D-Grafik

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen