std::partial_sum - cppreference.com

De cppreference.com

Definido no cabeçalho `<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)

Calcula as somas parciais dos elementos no subranges do [first, last) alcance e grava-los para o início escala em d_first. A primeira versão utiliza operator+ para resumir os elementos, a segunda versão utiliza a função binária dada 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.

Operação equivalente:

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);
...

Parâmetros

first, last	-	a gama de elementos a soma 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	-	o início do intervalo de destino 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`.

Valor de retorno

Iterador para o elemento passado o último elemento escrito.

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.

Complexidade

Exatamente (last - first) - 1 aplicações da operação binária

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.

Possível implementação

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;
}

Exemplo

#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';
}

Saída:

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

Veja também


	calcula as diferenças entre elementos adjacentes em forma de intervalo 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. (modelo de função) [edit]

	resume uma série de elementos 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. (modelo de função) [edit]