Espacios de nombres
Variantes
Acciones

std::transform_reduce

De cppreference.com
< cpp‎ | algorithm
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones de secuencia no modificantes
(C++11)(C++11)(C++11)
(C++17)
Operaciones de secuencia modificantes
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
(C++11)
Operaciones de búsqueda binaria
Operaciones de conjuntos (en rangos ordenados)
Operaciones de pila
(C++11)
(C++11)
Operaciones mínimo/máximo
(C++11)
(C++11)
(C++17)
(C++20)
Permutaciones
Operaciones numéricas
(C++17)
transform_reduce
(C++17)
Bibliotecas C
 
Definido en el archivo de encabezado <numeric>
(1)
template< class InputIt1, class InputIt2, class T >

T transform_reduce( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2,

                    T init );
 (desde C++17)
(hasta C++20)
template< class InputIt1, class InputIt2, class T >

constexpr
T transform_reduce( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2,

                    T init );
 (desde C++20)
(2)
template< class InputIt1, class InputIt2,

          class T,
          class BinaryReductionOp,
          class BinaryTransformOp >
T transform_reduce( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2,
                    T init,
                    BinaryReductionOp reduce,

                    BinaryTransformOp transform );
 (desde C++17)
(hasta C++20)
template< class InputIt1, class InputIt2,

          class T,
          class BinaryReductionOp,
          class BinaryTransformOp >
constexpr
T transform_reduce( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2,
                    T init,
                    BinaryReductionOp reduce,

                    BinaryTransformOp transform );
 (desde C++20)
(3)
template< class InputIt,

          class T,
          class BinaryReductionOp,
          class UnaryTransformOp >
T transform_reduce( InputIt first, InputIt last,
                    T init,
                    BinaryReductionOp reduce,

                    UnaryTransformOp transform );
 (desde C++17)
(hasta C++20)
template< class InputIt, class T,

          class BinaryReductionOp,
          class UnaryTransformOp >
constexpr
T transform_reduce( InputIt first, InputIt last,
                    T init,
                    BinaryReductionOp reduce,

                    UnaryTransformOp transform );
 (desde C++20)
template< class ExecutionPolicy,

          class ForwardIt1, class ForwardIt2, class T >
T transform_reduce( ExecutionPolicy&& policy,
                    ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 first2,

                    T init );
 (4) (desde C++17)
template< class ExecutionPolicy,

          class ForwardIt1, class ForwardIt2, class T,
          class BinaryReductionOp,
          class BinaryTransformOp >
T transform_reduce( ExecutionPolicy&& policy,
                    ForwardIt1 first1, ForwardIt1 last1,
                    ForwardIt2 first2,
                    T init,
                    BinaryReductionOp reduce,

                    BinaryTransformOp transform );
 (5) (desde C++17)
template< class ExecutionPolicy,

          class ForwardIt, class T,
          class BinaryReductionOp,
          class UnaryTransformOp >
T transform_reduce( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,
                    T init,
                    BinaryReductionOp reduce,

                    UnaryTransformOp transform );
 (6) (desde C++17)
1) Equivalente a std::transform_reduce(first1, last1, first2, init, std::plus<>(), std::multiplies<>());, efectivamente es una versión paralelizada de la función std::inner_product por defecto.
2) Aplica transform a cada par de elementos de los rangos [first; last) y el rango que comienza en first2 y reduce los resultados (posiblemente permutados y agregados de manera no especificada) junto con el valor inicial init sobre reduce.
3) Aplica transform a cada elemento en el rango [first; last) y reduce los resultados (posiblemente permutados y agregados de manera no especificada) junto con el valor inicial init sobre reduce.
4-6) Igual que (1-3), pero ejecutado de acuerdo con policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera..

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

El comportamiento no está definido si reduce o transform modifican cualquier elemento o invalidan cualquier iterador en los rangos de entrada, incluidos sus iteradores finales.

Contenido

[editar] Parámetros

first, last - El rango de elementos al que aplicar el algoritmo.
init - El valor inicial de la suma generalizada.
policy - La política de ejecución a utilizar. Véase política de ejecución para más detalles.
reduce - FunctionObject binario que se aplicará en un orden no especificado a los resultados de transform, los resultados de otro reduce e init.
transform - FunctionObject unario que se aplicará a cada elemento del rango de entrada. El tipo de retorno debe ser aceptable como entrada para reduce.
Requisitos de tipo
-
T debe satisfacer los requisitos de MoveConstructible para poder usar las sobrecargas (3,6). y el resultado de las expresiones reduce(init, transform(*first)), reduce(transform(*first), init), reduce(init, init), y reduce(transform(*first), transform(*first)) debe ser convertible a T
-
T debe satisfacer los requisitos de MoveConstructible para poder usar las sobrecargas (2,5). y el resultado de las expresiones reduce(init, transform(*first1, *first2)), reduce(transform(*first1, *first2), init), reduce(init, init), y reduce(transform(*first1, *first2), transform(*first1, *first2)) debe ser convertible a T
-
InputIt debe satisfacer los requisitos de InputIterator.
-
ForwardIt debe satisfacer los requisitos de ForwardIterator.

[editar] Valor de retorno

2) La suma generalizada init y transform(*first,*first2), transform(*(first+1),*(first2+1)), ..., sobre reduce
3) La suma generalizada init y transform(*first), transform(*(first+1)), ... transform(*(last-1)) sobre reduce,

donde la suma generalizada GSUM(op, a
1, ..., a
N) se define de la siguiente manera:

  • si N=1, a
    1    ;
  • si N > 1, op(GSUM(op, b
    1    , ..., b
    K    ), GSUM(op, b
    M    , ..., b
    N    ))     donde
  • b
    1    , ..., b
    N     puede ser cualquier permutación de a1, ..., aN y
  • 1 < K+1 = M ≤ N.

en otras palabras, los resultados de transform o de reduce pueden agruparse y organizarse en un orden arbitrario.

[editar] Complejidad

1,2,4,5) O(last1 - first1) aplicaciones cada una de reduce y transform.
3,6) O(last - first) aplicaciones cada una de transform y reduce.

[editar] Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan errores tales que:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

[editar] Notas

En la sobrecarga unaria-binaria (3,6), transform no se aplica a init.

Si first == last o first1 == last1, se devuelve init sin modificar.

[editar] Ejemplo

transform_reduce se puede usar para paralelizar std::inner_product:

Ejecuta este código
#include <vector>
#include <functional>
#include <iostream>
#include <numeric>
// #include <execution>
 
int main()
{
    std::vector<double> xvalues(10007, 1.0), yvalues(10007, 1.0);
 
    double result = std::transform_reduce(
    //  std::execution::par,
        xvalues.begin(), xvalues.end(),
        yvalues.begin(), 0.0
    );
    std::cout << result << '\n';
}

Salida: 

10007

[editar] Véase también

 Suma un rango de elementos
(plantilla de función) [editar]
Aplica una función a un rango de elementos
(plantilla de función) [editar]
(C++17)
 Similar a std::accumulate, excepto que fuera de orden
(plantilla de función) [editar]
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/algorithm/transform_reduce&oldid=41171»