std::partial_sum

Definido en el archivo de encabezado `<numeric>`
	(1)
`template< class InputIt, class OutputIt > OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );`			(hasta C++20)
`template< class InputIt, class OutputIt > constexpr OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );`			(desde C++20)
		(2)
`template< class InputIt, class OutputIt, class BinaryOperation > OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );`				(hasta C++20)
`template< class InputIt, class OutputIt, class BinaryOperation > constexpr OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first, BinaryOperation op );`				(desde C++20)

Calcula las sumas parciales de los elementos en los subrangos del rango [first, last) y las escribe en el rango que comienza en d_first. La primera versión utiliza operator+ para sumar los elementos, la segunda versión utiliza la función binaria dada op, ambas aplican std::move a sus operandos en el lado izquierdo (desde C++20).

Operación equivalente:

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

`op` no debe tener efectos secundarios.	(hasta C++11)
`op` no debe invalidar ningún iterador, incluso los iteradores al final, o modificar ningún elemento del rango involucrado.	(desde C++11)

Parámetros

first, last	-	El rango de elementos a sumar
d_first	-	El inicio del rango destino; puede ser igual a `first`
op	-	Función objeto de operación binaria que se aplicará. La signatura de la función deberá ser equivalente a lo siguiente: `Ret fun(const Type1 &a, const Type2 &b);` La signatura no necesita tener `const &`. El tipo `Type1` debe ser tal que un objeto de tipo `iterator_traits<InputIt>::value_type` puede convertirse implícitamente a `Type1`. El tipo `Type2` debe ser tal que un objeto de tipo `InputIt` puede ser desreferenciado y luego convertido implícitamente a `Type2`. El tipo `Ret` debe ser tal que un objeto de tipo `iterator_traits<InputIt>::value_type` puede ser asignado un valor de tipo `Ret`.
Requisitos de tipo
- `InputIt` debe satisfacer los requisitos de InputIterator.
- `OutputIt` debe satisfacer los requisitos de OutputIterator.

Valor de retorno

Iterador al elemento después del último elemento escrito.

Complejidad

Exactamente (last - first) - 1 aplicaciones de la operación binaria.

Posible implementación

Primera versión

template<class InputIt, class OutputIt>
constexpr // desde C++20
OutputIt partial_sum(InputIt first, InputIt last, 
                     OutputIt d_first)
{
    if (first == last) return d_first;

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

    while (++first != last) {
       sum = std::move(sum) + *first; // std::move desde C++20
       *++d_first = sum;
    }
    return ++d_first;

    // o, desde C++14:
    // return std::partial_sum(first, last, d_first, std::plus<>());
}

Segunda versión

template<class InputIt, class OutputIt, class BinaryOperation>
constexpr // desde C++20
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(std::move(sum), *first); // std::move desde C++20
       *++d_first = sum;
    }
    return ++d_first;
}

Ejemplo

Ejecuta este código

#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}; // o std::vector<int>v(10, 2);

    std::cout << "Los primeros 10 numeros pares son: ";
    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 << "Las primeras 10 potencias de 2 son: ";
    for (auto n : v) {
        std::cout << n << " ";
    }
    std::cout << '\n';
}

Salida:

Los primeros 10 numeros pares son: 2 4 6 8 10 12 14 16 18 20 
Las primeras 10 potencias de 2 son: 2 4 8 16 32 64 128 256 512 1024

Véase también

adjacent_difference	Calcula las diferencias entre elementos adyacentes en un rango (plantilla de función) [editar]
accumulate	Suma un rango de elementos (plantilla de función) [editar]
inclusive_scan (C++17)	Similar a std::partial_sum, incluye el i-ésimo elemento de entrada de la i-ésima suma (plantilla de función) [editar]
exclusive_scan (C++17)	Similar a std::partial_sum, excluye el i-ésimo elemento de entrada de la i-ésima suma (plantilla de función) [editar]

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones