namespace std { template <class InputIterator, class T> T accumulate(InputIterator first, InputIterator last, T init); template <class InputIterator, class T, class BinaryOperation> T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); template <class InputIterator1, class InputIterator2, class T> T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2> T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); template <class InputIterator, class OutputIterator> OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result); template <class InputIterator, class OutputIterator, class BinaryOperation> OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); template <class InputIterator, class OutputIterator> OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result); template <class InputIterator, class OutputIterator, class BinaryOperation> OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); template <class ForwardIterator, class T> void iota(ForwardIterator first, ForwardIterator last, T value); }

The requirements on the types of algorithms' arguments that are described in the introduction to Clause [algorithms] also apply to the following algorithms.

```
template <class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init);
template <class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init,
BinaryOperation binary_op);
```

*Effects:*
Computes its result by initializing the accumulator
acc
with the initial value
init
and then modifies it with
acc = acc + *i
or
acc = binary_op(acc, *i)
for every iterator
i
in the range [first,last)
in order.289

*Requires:*
T shall meet the requirements of CopyConstructible (Table [copyconstructible])
and CopyAssignable (Table [copyassignable]) types.
In the range
[first,last],
binary_op
shall neither modify elements nor invalidate iterators or subranges.290

accumulate is similar to the APL reduction operator and Common Lisp reduce function, but it avoids the difficulty of defining the result of reduction on an empty sequence by always requiring an initial value.

The use of fully closed ranges is intentional

```
template <class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init);
template <class InputIterator1, class InputIterator2, class T,
class BinaryOperation1, class BinaryOperation2>
T inner_product(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init,
BinaryOperation1 binary_op1,
BinaryOperation2 binary_op2);
```

*Effects:*
Computes its result by initializing the accumulator
acc
with the initial value
init
and then modifying it with
acc = acc + (*i1) * (*i2)
or
acc = binary_op1(acc, binary_op2(*i1, *i2))
for every iterator
i1
in the range [first1,last1)
and iterator
i2
in the range
[first2,first2 + (last1 - first1))
in order.

*Requires:*
T shall meet the requirements of CopyConstructible (Table [copyconstructible])
and CopyAssignable (Table [copyassignable]) types.
In the ranges
[first1,last1]
and
[first2,first2 + (last1 - first1)]
binary_op1
and
binary_op2
shall neither modify elements nor invalidate iterators or subranges.291

The use of fully closed ranges is intentional

```
template <class InputIterator, class OutputIterator>
OutputIterator partial_sum(
InputIterator first, InputIterator last,
OutputIterator result);
template
<class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator partial_sum(
InputIterator first, InputIterator last,
OutputIterator result, BinaryOperation binary_op);
```

*Effects:* For a non-empty range,
the function creates an accumulator acc whose type is InputIterator's
value type, initializes it with *first,
and assigns the result to *result. For every iterator i in [first + 1,last)
in order, acc is then modified by acc = acc + *i or acc = binary_op(acc, *i)
and the result is assigned to *(result + (i - first)).

*Returns:*
result + (last - first).

*Complexity:*
Exactly
(last - first) - 1
applications of
the binary operation.

*Requires:*
InputIterator's value type shall be constructible from the type of *first.
The result of the expression acc + *i or binary_op(acc, *i) shall be
implicitly convertible to InputIterator's value type. acc
shall be writable to the result output iterator.
In the ranges
[first,last]
and
[result,result + (last - first)]
binary_op
shall neither modify elements nor invalidate iterators or subranges.292

*Remarks:*
result
may be equal to
first.

The use of fully closed ranges is intentional.

```
template <class InputIterator, class OutputIterator>
OutputIterator adjacent_difference(
InputIterator first, InputIterator last,
OutputIterator result);
template <class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator adjacent_difference(
InputIterator first, InputIterator last,
OutputIterator result,
BinaryOperation binary_op);
```

*Effects:* For a non-empty range,
the function creates an accumulator acc whose type is InputIterator's
value type, initializes it with *first,
and assigns the result to *result. For every iterator i in [first + 1,last)
in order, creates an object val whose type is InputIterator's value type, initializes it
with *i, computes val - acc or binary_op(val, acc), assigns the result
to *(result + (i - first)), and move assigns from val to acc.

*Requires:*
InputIterator's value type shall be MoveAssignable (Table [moveassignable])
and shall be constructible from the type of *first. acc shall be
writable to the result output iterator. The result of the expression val - acc
or binary_op(val, acc) shall be writable to the result output iterator.
In the ranges
[first,last]
and
[result,result + (last - first)],
binary_op
shall neither modify elements nor invalidate iterators or
subranges.293

*Remarks:*
result
may be equal to
first.

*Returns:*
result + (last - first).

*Complexity:*
Exactly
(last - first) - 1
applications of
the binary operation.

The use of fully closed ranges is intentional.

```
template <class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last, T value);
```

*Requires:* T shall be convertible to ForwardIterator's value
type. The expression ++val, where val has type T, shall
be well formed.

*Effects:* For each element referred to by the iterator i in the range
[first,last), assigns *i = value and increments value as
if by ++value.

*Complexity:* Exactly last - first increments and assignments.