std::partial_sum — cppreference.com

De cppreference.com

Déclaré dans l'en-tête `<numeric>`
`template< class InputIt, class OutputIt > OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );`	(1)
`template< class InputIt, class OutputIt, class BinaryOperation > OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );`	(2)

Calcule les sommes partielles des éléments de la sous-gammes de [first, last) gamme et les écrit dans le début de la plage à d_first. La première version utilise operator+ de résumer les éléments, la deuxième version utilise la fonction binaire donné op .

Original:

Computes the partial sums of the elements in the subranges of the range [first, last) and writes them to the range beginning at d_first. The first version uses operator+ to sum up the elements, the second version uses the given binary function op.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Opération équivalente:

Original:

Equivalent operation:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

*(d_first)   = *first;
*(d_first+1) = *first + *(first+1);
*(d_first+2) = *first + *(first+1) + *(first+2);
*(d_first+3) = *first + *(first+1) + *(first+2) + *(first+3);
...

Paramètres

first, last	-	la gamme des éléments de somme Original: the range of elements to sum The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
d_first	-	le début de la plage de destination Original: the beginning of the destination range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
op	-	binary operation function object that will be applied. The signature of the function should be equivalent to the following: `Ret fun(const Type1 &a, const Type2 &b);` The signature does not need to have `const &`. The type `Type1` must be such that an object of type `iterator_traits<InputIt>::value_type` can be implicitly converted to `Type1`. The type `Type2` must be such that an object of type `InputIt` can be dereferenced and then implicitly converted to `Type2`. The type `Ret` must be such that an object of type `iterator_traits<InputIt>::value_type` can be assigned a value of type `Ret`.
Type requirements
-`InputIt` must meet the requirements of `InputIterator`.
-`OutputIt` must meet the requirements of `OutputIterator`.

Retourne la valeur

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

Original:

Iterator to the element past the last element written.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Complexité

Exactement (last - first) - 1 applications de l'opération binaire

Original:

Exactly (last - first) - 1 applications of the binary operation

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Mise en œuvre possible

First version
template<class InputIt, class OutputIt> OutputIt partial_sum(InputIt first, InputIt last, OutputIt d_first) { return std::partial_sum(first, last, d_first, std::plus<InputIt, InputIt>()); }
Second version
template<class InputIt, class OutputIt, class BinaryOperator> OutputIt partial_sum(InputIt first, InputIt last, OutputIt d_first, BinaryOperation op) { if (first == last) return d_first; typename std::iterator_traits<InputIt>::value_type sum = first; d_first = sum; while (++first != last) { sum = op(sum, first); ++d_first = sum; } return ++d_first; }

First version

template<class InputIt, class OutputIt>
OutputIt partial_sum(InputIt first, InputIt last, 
                           OutputIt d_first)
{
    return std::partial_sum(first, last, d_first, 
                            std::plus<InputIt, InputIt>());
}

Second version

template<class InputIt, class OutputIt, class BinaryOperator>
OutputIt partial_sum(InputIt first, InputIt last, 
                           OutputIt d_first, BinaryOperation op)
{
    if (first == last) return d_first;

    typename std::iterator_traits<InputIt>::value_type sum = *first;
    *d_first = sum;

    while (++first != last) {
       sum = op(sum, *first);
       *++d_first = sum;
    }
    return ++d_first;
}

Exemple

#include <numeric>
#include <vector>
#include <iostream>
#include <iterator>
#include <functional>
int main()
{
    std::vector<int> v = {2,2,2,2,2,2,2,2,2,2};

    std::cout << "The first 10 even numbers are: ";
    std::partial_sum(v.begin(), v.end(), 
                     std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';

    std::partial_sum(v.begin(), v.end(), v.begin(), std::multiplies<int>());
    std::cout << "The first 10 powers of 2 are: ";
    for(auto n: v) {
        std::cout << n << " ";
    }
    std::cout << '\n';
}

Résultat :

The first 10 even numbers are: 2 4 6 8 10 12 14 16 18 20 
The first 10 powers of 2 are: 2 4 8 16 32 64 128 256 512 1024

Voir aussi


	calcule les différences entre les éléments adjacents dans une gamme Original: computes the differences between adjacent elements in a range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique) [edit]

	résume un ensemble d'éléments Original: sums up a range of elements The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique) [edit]