std::transform_reduce - cppreference.com

</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>

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

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.

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

#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';
}

Véase también