std:: transform_exclusive_scan

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 ne contient qu'un seul élément, la somme est la valeur de cet élément.
• Sinon, effectue les opérations suivantes dans l'ordre :

1. Sélectionne deux éléments adjacents quelconques elem1 et elem2 dans 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 ne reste 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 un élément quelconque de [ first , last ) .
• unary_op ou binary_op invalide un itérateur ou un sous-intervalle quelconque 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