std::transform_inclusive_scan

template< class InputIt, class OutputIt,
          class BinaryOp, class UnaryOp >
OutputIt transform_inclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first,
      BinaryOp binary_op, UnaryOp unary_op );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2,
          class BinaryOp, class UnaryOp >
ForwardIt2 transform_inclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
      BinaryOp binary_op, UnaryOp unary_op );

template< class InputIt, class OutputIt,
          class BinaryOp, class UnaryOp, class T >
OutputIt transform_inclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first,
      BinaryOp binary_op, UnaryOp unary_op, T init );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2,
          class BinaryOp, class UnaryOp, class T >
ForwardIt2 transform_inclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
      BinaryOp binary_op, UnaryOp unary_op, T init );

La somme généralisée non commutative d'une séquence d'éléments sur une opération binaire binary_op est définie comme suit :

• Si la séquence n'a qu'un seul élément, la somme est la valeur de l'élément.
• Sinon, effectue les opérations suivantes dans l'ordre :

1. Sélectionne deux éléments adjacents elem1 et elem2 de la séquence.
2. Calcule binary_op(elem1, elem2) et remplace les deux éléments de la séquence par le résultat.
3. Répète les étapes 1 et 2 jusqu'à ce qu'il n'y ait plus qu'un seul élément dans la séquence.

Le résultat est non déterministe si binary_op n'est pas associative (comme l'addition en virgule flottante).

Pour les surcharges (1,2), si binary_op(unary_op(*first), unary_op(*first)) n'est pas convertible en type de valeur de decltype(first), le programme est mal formé.

Pour les surcharges (3,4), si l'une des valeurs suivantes n'est pas convertible en T, le programme est mal formé :

• binary_op(init, init)
• binary_op(init, unary_op(*first))
• binary_op(unary_op(*first), unary_op(*first))

Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

• Pour les surcharges (1,2), le type de valeur de decltype(first) n'est pas MoveConstructible.
• Pour les surcharges (3,4), T n'est pas MoveConstructible.
• unary_op ou binary_op modifie tout élément de [first, last).
• unary_op ou binary_op invalide tout itérateur ou sous-plage de [first, last].

Paramètres

Valeur de retour

Itérateur vers l'élément après le dernier élément écrit.

Complexité

Étant donné \(\scriptsize N\) N comme std:: distance ( first, last ) :

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
• Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Notes

unary_op n'est jamais appliqué à init .

Le paramètre init apparaît en dernier, différant de std::transform_exclusive_scan , car il est optionnel pour cette fonction.

Exemple

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};
    auto times_10 = [](int x) { return x * 10; };
    std::cout << "Somme exclusive multipliée par 10 : ";
    std::transform_exclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  0, std::plus<int>{}, times_10);
    std::cout << "\nSomme inclusive multipliée par 10 : ";
    std::transform_inclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  std::plus<int>{}, times_10);
    std::cout << '\n';
}

Somme exclusive multipliée par 10 : 0 30 40 80 90 140 230 250 
Somme inclusive multipliée par 10 : 30 40 80 90 140 230 250 310

Voir aussi