std::transform_reduce
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
| 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.
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.
| ||
Valor de retorno
2) La suma generalizada
init y transform(*first,*first2), transform(*(first+1),*(first2+1)), ..., sobre reduce3) 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.
- b
en otras palabras, los resultados de transform o de reduce pueden agruparse y organizarse en un orden arbitrario.
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.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.
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.
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
Véase también
| Suma un rango de elementos (plantilla de función) | |
| Aplica una función a un rango de elementos (plantilla de función) | |
(C++17) |
Similar a std::accumulate, excepto que fuera de orden (plantilla de función) |