std:: inclusive_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.

Étant donné binary_op comme l'opération binaire réelle :

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

• Pour les surcharges (1-4) , si binary_op ( * first, * first ) n'est pas convertible vers le type de valeur de decltype ( first ) , le programme est mal formé.

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

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

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

• Pour les surcharges (1-4) , le type de valeur de decltype ( first ) n'est pas MoveConstructible .
• Pour les surcharges (5,6) , T n'est pas MoveConstructible .
• binary_op modifie tout élément de [ first , last ) .
• binary_op invalide tout itérateur ou sous-intervalle 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é.

Exemple

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};
    std::cout << "Somme exclusive : ";
    std::exclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "),
                        0);
    std::cout << "\nSomme inclusive : ";
    std::inclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n\nProduit exclusif : ";
    std::exclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "),
                        1, std::multiplies<>{});
    std::cout << "\nProduit inclusif : ";
    std::inclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "),
                        std::multiplies<>{});
}

Somme exclusive : 0 3 4 8 9 14 23 25
Somme inclusive : 3 4 8 9 14 23 25 31
Produit exclusif : 1 3 3 12 12 60 540 1080
Produit inclusif : 3 3 12 12 60 540 1080 6480

Voir aussi