Table G.16 summarizes the numeric operations, which are described by the numeric
header file. Arguments are not shown, and overloaded functions are listed just once. Each function has a version that uses <
for ordering elements and a version that uses a comparison function object for ordering elements. A fuller description, including the prototypes, follows the table. Thus, you can scan the table to get an idea of what a function does and then look up the details if you find the function appealing.
Now let’s take a more detailed look at these numeric operations. For each function, the discussion shows the prototype(s), followed by a brief explanation.
accumulate()
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);
The accumulate()
function initializes a value acc
to init
; then it performs the operation acc = acc + *i
(first version) or acc = binary_op(acc, *i)
(second version) for each iterator i
in the range [first
, last
), in order. It then returns the resulting value of acc
.
inner_product()
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);
The inner_product()
function initializes a value acc
to init
; then it performs the operation acc = *i * *j
(first version) or acc = binary_op(*i, *j)
(second version) for each iterator i
in the range [first1
, last1
), in order, and each corresponding iterator j
in the range [first2
, first2 + (last1 - first1)
). That is, it calculates a value from the first elements from each sequence, then from the second elements of each sequence, and so on, until it reaches the end of the first sequence. (Hence the second sequence should be at least as long as the first.) The function then returns the resulting value of acc
.
partial_sum()
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);
The partial_sum()
function assigns *first
to *result
or *first + *(first + 1)
to *(result + 1)
(first version) or it assigns binary_op(*first, *(first + 1))
to *(result + 1)
(second version), and so on. That is, the n
th element of the sequence beginning at result
contains the sum (or binary_op
equivalent) of the first n
elements of the sequence beginning at first
. The function returns the past-the-end iterator for the result. The algorithm allows result
to be first
—that is, it allows the result to be copied over the original sequence, if desired.
adjacent_difference()
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);
The adjacent_difference()
function assigns *first
to the location result
(*result = *first
). Subsequent locations in the target range are assigned the differences (or binary_op
equivalent) of adjacent locations in the source range. That is, the next location in the target range (result + 1
) is assigned *(first + 1) - *first
(first version) or binary_op(*(first + 1), *first)
(second version), and so on. The function returns the past-the-end iterator for the result. The algorithm allows result
to be first
—that is, it allows the result to be copied over the original sequence, if desired.
iota()
(C++11)template <class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last,T value);
The iota()
function assigns value
to *first
, increases value
as if by ++value
, assigns the new value
to the next element in the range, and so on until the last element.
3.14.141.115