función transform_inclusive_scan() en C++

transform_inclusive_scan() es una función incorporada en C++ y es igual que inclusive_scan(), excepto una función unaria que se aplica primero a cada elemento de entrada.
Su funcionalidad es transformar todos y cada uno de los elementos entre el primero y el último con unary_op y luego calcula una operación de suma de prefijos inclusivos con la ayuda de binary_op con un rango específico. Un elemento de entrada i-ésimo inclusivo definido se incluye en la operación de suma i-ésima. 
Podemos tomar un inicio opcional (valores iniciales) y escribir los resultados en el rango que comienza en d_first. 

Sintaxis:

template < class InputItrator, class OutputItrator,
          class BinaryOperation, class UnaryOperation >

OutputItrator transform_inclusive_scan( InputItrator first, 
                                        InputItrator last,
                                        OutputItrator d_first,
                                        BinaryOperation binary_op,
                                        UnaryOperation unary_op 
                                     );

Parámetros utilizados:

• primero y último: – Los elementos primero y último definen el rango de una suma de elementos.
• d_first:- Su comienzo del rango de destino.
• unary_op: – Operación que se aplicará en cada elemento en el rango de entrada.
• binary_op: operación que se aplicará al resultado de unary_op y los resultados de otro binary_op, y si se proporcionará init (valor inicial).

Requisitos de tipo:

• InputItrator : Inputiterator es una clase de iterador y puede leer desde el elemento apuntado. Si una vez que he incrementado, todas las demás copias se invalidan y su validez para el algoritmo de un solo paso.
• OutputItrator : OutputIterator es un iterador que se puede escribir en el elemento señalado.

Valores devueltos: un iterador al elemento más allá del último elemento escrito.

Nota: Unary_op es opcional en esta función y no se aplica a init. En realidad, el parámetro init aparece por fin.

A continuación se muestra la implementación del problema anterior.

// C++ program by used std::transform_inclusive_scan() function
// to transforms each and every elements between first
// and last with unary_op, then computes an inclusive prefix sum
#include <iostream>
#include <vector>
using namespace std;
 
namespace geeksInputIterator {
template <class InputItrator, class OutputItrator,
          class BinaryOperation, class UnaryOperation>
 
OutputItrator transform_inclusive_scan(InputItrator first,
                                       InputItrator last,
                                       OutputItrator d_first,
                                       BinaryOperation binary_op,
                                       UnaryOperation unary_op)
{
    *d_first = unary_op(*first);
    first++;
    d_first++;
    for (auto it = first; it != last; it++) {
 
        // calculate the prefix sum
        *d_first = binary_op(unary_op(*it), *(d_first - 1));
        d_first++;
    }
    return d_first;
}
}
 
// Driver code
int main()
{
    // input elements
    vector<int> InputVector{ 11, 22, 33, 44, 55, 66, 77, 88 };
 
    // OutputVector elements size
    vector<int> OutputVector(8);
 
    // inclusive transform function with begin and ending
    geeksInputIterator::transform_inclusive_scan(InputVector.begin(),
                   InputVector.end(), OutputVector.begin(),
                   [](auto xx, auto yy) {
                     return xx + yy;
                      },
                   [](auto xx) {
                     return xx * xx;
});
    // for loop for print output
    for (auto item : OutputVector) {
 
        // Print the output item
        cout << item << " ";
    }
 
    // to move next line
    cout << std::endl;
    return 0;
}

Producción:

121 605 1694 3630 6655 11011 16940 24684 

Nota: Es posible que el programa anterior no se ejecute en muchos IDE.