std::transform_exclusive_scan

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

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

La somme non commutative généralisée 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 quelconques elem1 et elem2 de la séquence.
2. Calcule binary_op(elem1, elem2) et remplace les deux éléments dans la séquence par le résultat.
3. Répète les étapes 1 et 2 jusqu'à ce qu'il n'y ait qu'un seul élément dans la séquence.

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

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 :

• 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

La surcharge avec un paramètre de modèle nommé ExecutionPolicy signale 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é.

Notes

unary_op n'est jamais appliqué à init .

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