## Pages

### Partial sum

Given a numeric sequence, its partial summation is another sequence where each element represents the sum of all the elements of the original sequence till that point. So, given the sequence { 1, 1, 1, ... }, its partial sum is { 1, 2, 3, 4, ... }. It is also known as prefix sum, prefix reduction, scan, or cumulative sum.

There is a C++ STL function that implements this concept, std::partial_sum(), available in two overloads. One is a proper partial sum implementation, the other is a generic one, that lets the caller to specify which kind of operation applying to transform the original sequence.

I have written a few test cases (for GoogleTest) that should clarify better its usage.

Typical case

I have an input sequence, I want to get its partial sum in a new container:
```TEST(TestParSum, CaseStandard)
{
std::vector<int> input { 1, 3, 1, 4, 2, 3, 5, 4 }; // 1
std::vector<int> output(input.size()); // 2
std::partial_sum(input.begin(), input.end(), output.begin()); // 3

ASSERT_EQ(8, output.size());
ASSERT_EQ(1, output[0]);
ASSERT_EQ(4, output[1]);
ASSERT_EQ(5, output[2]);
ASSERT_EQ(9, output[3]);
ASSERT_EQ(11, output[4]);
ASSERT_EQ(14, output[5]);
ASSERT_EQ(19, output[6]);
ASSERT_EQ(23, output[7]);
}
```
1. The original container. I have used the handy C++11 list initalizer to set it up on construction.
2. The generated result will be stored in this container. It should have the same size of the input sequence.
3. Calculate the partial sum for the passed sequence, putting the result starting from the beginning of the output container.

In place generation

The standard partial_sum() function is designed in such a way that it could overwrite the original data:
```TEST(TestParSum, CaseOverwrite)
{
std::vector<int> data { 1, 3, 1, 4, 2, 3, 5, 4 };
std::partial_sum(data.begin(), data.end(), data.begin()); // 1

ASSERT_EQ(8, data.size());
ASSERT_EQ(1, data[0]);
ASSERT_EQ(4, data[1]);
ASSERT_EQ(5, data[2]);
ASSERT_EQ(9, data[3]);
ASSERT_EQ(11, data[4]);
ASSERT_EQ(14, data[5]);
ASSERT_EQ(19, data[6]);
ASSERT_EQ(23, data[7]);
}
```
1. The output iterator is the same that the input starter iterator. We are about to lose the original data, but we are saving some space in memory.

Not only summations

We could need something similar to a partial sum, with the variation that the operator applied is not an addition:
```TEST(TestParSum, CaseMultiply)
{
std::vector<int> data { 1, 3, 1, 4, 2, 3, 5, 4 };
std::partial_sum(data.begin(), data.end(), data.begin(),
std::multiplies<int>()); // 1

ASSERT_EQ(8, data.size());
ASSERT_EQ(1, data[0]);
ASSERT_EQ(3, data[1]);
ASSERT_EQ(3, data[2]);
ASSERT_EQ(12, data[3]);
ASSERT_EQ(24, data[4]);
ASSERT_EQ(72, data[5]);
ASSERT_EQ(360, data[6]);
ASSERT_EQ(1440, data[7]);
}
```
1. Instead of summing, I want to multiply the values. So I pass the STL multiplies functor as last parameter. Nothing else changes from a "normal" partial_sum() call.

Even more generalized

Obviously, we are not restricted to use STL arithmetic functors as a binary operation. We could use our own specifically tailored functor or, if our compiler is C++11 compliant, lambda function.

Here I just rewrite the previous test:
```TEST(TestParSum, CaseMultiplyLambda)
{
std::vector<int> data { 1, 3, 1, 4, 2, 3, 5, 4 };
std::partial_sum(data.begin(), data.end(), data.begin(),
[](int a, int b) { return a*b; });

ASSERT_EQ(8, data.size());
ASSERT_EQ(1, data[0]);
ASSERT_EQ(3, data[1]);
ASSERT_EQ(3, data[2]);
ASSERT_EQ(12, data[3]);
ASSERT_EQ(24, data[4]);
ASSERT_EQ(72, data[5]);
ASSERT_EQ(360, data[6]);
ASSERT_EQ(1440, data[7]);
}
```