Namespaces
Variants

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

From cppreference.net
C++
Experimental
Extensions for parallelism v2
SIMD library
Definido en el encabezado <experimental/simd>
template < class T, class Abi, class BinaryOperation = std:: plus <> >
T reduce ( const simd < T, Abi > & v, BinaryOperation binary_op = { } ) ;
(1) (TS de paralelismo v2)
template < class M, class V, class BinaryOperation >

typename V :: value_type
reduce ( const const_where_expression < M, V > & x,

typename V :: value_type elemento_identidad, BinaryOperation operacion_binaria = { } ) ;
(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

reduce ( const const_where_expression < M, V > & x, std:: multiplies <> binary_op ) 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) (parallelism 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) (TS de paralelismo 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) Reduce todos los valores en v mediante binary_op .
2) Reduce los valores en x donde el elemento de máscara asociado es true mediante binary_op .
3) Devuelve la suma de todos los valores en x donde el elemento de máscara asociado es true .
4) Devuelve el producto de todos los valores en x donde el elemento de máscara asociado es true .
5) Devuelve la agregación usando el operador AND a nivel de bits de todos los valores en x donde el elemento de máscara asociado es true .
6) Devuelve la agregación usando OR bit a bit de todos los valores en x donde el elemento de máscara asociado es true .
7) Devuelve la agregación usando el operador bitwise-xor de todos los valores en x donde el elemento de máscara asociado es true .
8) Reduce todos los valores en v mediante std:: min .
9) Reduce todos los valores en x donde el elemento de máscara asociado es true mediante std:: min .
10) Reduce todos los valores en v sobre std:: max .
11) Reduce todos los valores en x donde el elemento de máscara asociado es true sobre std:: max .

El comportamiento es no determinista si binary_op no es asociativo o no es conmutativo.

Contenidos

Parámetros

v - el vector simd al que aplicar la reducción
x - el valor de retorno de una expresión where a la que aplicar la reducción
identity_element - un valor que actúa como elemento identidad para binary_op ; binary_op ( identity_element, a ) == a debe cumplirse para todo a finito de tipo V :: value_type
binary_op - objeto función binario FunctionObject que se aplicará en orden no especificado a argumentos de tipo V :: value_type o simd < V :: value_type , A > , con etiqueta ABI no especificada A . binary_op ( v, v ) debe ser convertible a V

Valor de retorno

El resultado de la operación del tipo:

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

Ejemplo

Ejecutar este código 
#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);
}

Salida: 

sum of data = 523776

Véase también

(C++17)
similar a std::accumulate , excepto que es fuera de orden
(plantilla de función)