Namespaces
Variants

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

From cppreference.net
C++
Experimental
Extensions for parallelism v2
SIMD library
**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises spécifiques au code et contient des termes techniques C++ qui doivent rester en anglais. Seul le texte visible en dehors des balises de code aurait dû être traduit, mais dans cet extrait, il n'y a pratiquement pas de texte à traduire en dehors des numéros de version et des libellés techniques. **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` ` avec la classe `mw-geshi cpp source-cpp` qui indique qu'il s'agit de code. Seul le texte en dehors des éléments de code a été traduit, mais dans cet extrait spécifique, tout le contenu textuel fait partie du code C++ ou de la numérotation, donc aucune traduction n'a été appliquée. **Note:** Le code C++ n'a pas été traduit car il contient des termes spécifiques au C++ et se trouve dans des balises de code. Seul le texte anglais environnant a été traduit en français, conformément aux instructions.
Défini dans l'en-tête <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 élément_identité, BinaryOperation opération_binaire = { } ) ;
(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) (parallelism TS v2)
template < class M, class V >

typename V :: value_type

réduire ( const const_where_expression < M, V > & x, std:: multiplies <> opération_binaire ) 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

réduire ( const const_where_expression < M, V > & x, std:: bit_or <> opération_binaire ) noexcept ;
(6) (parallelism TS v2)
template < class M, class V >

typename V :: value_type

réduire ( const const_where_expression < M, V > & x, std:: bit_xor <> opération_binaire ) 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) (TS parallélisme v2)
template < class T, class Abi >
T hmax ( const simd < T, Abi > & v ) noexcept ;
(10) (TS parallélisme v2)
template < class M, class V >

typename V :: value_type

hmax ( const const_where_expression < M, V > & x ) noexcept ;
(11) (parallelism TS v2)
1) Réduit toutes les valeurs dans v via binary_op .
2) Réduit les valeurs dans x où l'élément de masque associé est true via binary_op .
3) Retourne la somme de toutes les valeurs dans x où l'élément de masque associé est true .
4) Retourne le produit de toutes les valeurs dans x où l'élément de masque associé est true .
5) Retourne l'agrégation utilisant le ET binaire de toutes les valeurs dans x où l'élément de masque associé est true .
6) Retourne l'agrégation utilisant le OU binaire de toutes les valeurs dans x où l'élément de masque associé est true .
7) Retourne l'agrégation utilisant le OU exclusif binaire de toutes les valeurs dans x où l'élément de masque associé est true .
8) Réduit toutes les valeurs dans v via std:: min .
9) Réduit toutes les valeurs dans x où l'élément de masque associé est true via std:: min .
10) Réduit toutes les valeurs dans v via std:: max .
11) Réduit toutes les valeurs dans x où l'élément de masque associé est true via std:: max .

Le comportement est non déterministe si binary_op n'est pas associatif ou n'est pas commutatif.

Table des matières

Paramètres

v - le vecteur simd auquel appliquer la réduction
x - la valeur de retour d'une expression where à laquelle appliquer la réduction
identity_element - une valeur qui agit comme élément neutre pour binary_op ; binary_op ( identity_element, a ) == a doit être vérifié pour toute valeur finie a de type V :: value_type
binary_op - un FunctionObject binaire qui sera appliqué dans un ordre non spécifié à des arguments de type V :: value_type ou simd < V :: value_type , A > , avec une balise ABI non spécifiée A . binary_op ( v, v ) doit être convertible en V

Valeur de retour

Le résultat de l'opération du type :

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

Exemple

Exécuter ce 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);
}

Sortie : 

sum of data = 523776

Voir aussi

(C++17)
similaire à std::accumulate , mais sans ordre défini
(modèle de fonction)