Espacios de nombres
Variantes
Acciones

std::partial_sum

De cppreference.com
< cpp‎ | algorithm

 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones no modificadoras de secuencia
(C++11)(C++11)(C++11)
(C++17)
Operaciones modificadoras de secuencia
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de set (en rangos ordenados)
Operaciones de pila
(C++11)
Operaciones minimo/maximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
partial_sum
Bibliotecas C
 
Definido en la cabecera <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 las sumas parciales de los elementos en los subintervalos del intervalo [first, last) y los escribe en el comienzo rango en d_first. La primera versión utiliza operator+ resumir los elementos, la segunda versión utiliza la función binaria dado 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.
Equivalente operación:
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);
...

Contenido

[editar] Parámetros

first, last -
el intervalo de elementos de suma
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 -
el comienzo del rango 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. ​

Requerimientos de tipo
-
InputIt debe reunir los requerimientos de InputIterator.
-
OutputIt debe reunir los requerimientos de OutputIterator.

[editar] Valor de retorno

Iterator al elemento más allá del ú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.

[editar] Complejidad

Exactamente (last - first) - 1 aplicaciones de la operación binaria
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.

[editar] Posible implementación

Primera versión
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>());
}
Segunda versión
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;
}

[editar] Ejemplo

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

Salida:

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

[editar] Ver también

calcula las diferencias entre elementos adyacentes en un rango
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.

(plantilla de función) [editar]
resume una serie 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.

(plantilla de función) [editar]