There are four generalized functions in the <numeric> header
that follow the same conventions as those in <algorithm>. Each
of them is overloaded: one signature for common default operations,
and a second for fully general operations. Their names are
self-explanatory to anyone who works with numerics on a regular basis:

Here is a simple example of the two forms of `accumulate`

.

int ar[50];
int someval = somefunction();
// ...initialize members of ar to something...
int sum = std::accumulate(ar,ar+50,0);
int sum_stuff = std::accumulate(ar,ar+50,someval);
int product = std::accumulate(ar,ar+50,1,std::multiplies<int>());

The first call adds all the members of the array, using zero as an
initial value for `sum`

. The second does the same, but uses
`someval`

as the starting value (thus, ```
sum_stuff == sum +
someval
```

). The final call uses the second of the two signatures,
and multiplies all the members of the array; here we must obviously
use 1 as a starting value instead of 0.

The other three functions have similar dual-signature forms.