std::adjacent_difference
Defined in header
<numeric>
|
||
template< class InputIt, class OutputIt >
OutputIt adjacent_difference( InputIt first, InputIt last, |
(1) | |
template< class InputIt, class OutputIt, class BinaryOperation >
OutputIt adjacent_difference( InputIt first, InputIt last, |
(2) | |
Computes the differences between the second and the first of each adjacent pair of elements of the range [first, last)
and writes them to the range beginning at d_first + 1
. Unmodified copy of first
is written to d_first
. The first version uses operator-
to calculate the differences, the second version uses the given binary function op
.
Equivalent operation:
*(d_first) = *first; *(d_first+1) = *(first+1) - *(first); *(d_first+2) = *(first+2) - *(first+1); *(d_first+3) = *(first+3) - *(first+2); ...
|
(until C++11) |
|
(since C++11) |
Contents |
[edit] Parameters
first, last | - | the range of elements |
d_first | - | the beginning of the destination range |
op | - | binary operation function object that will be applied. The signature of the function should be equivalent to the following: Ret fun(const Type1 &a, const Type2 &b); The signature does not need to have const &. |
Type requirements | ||
-
InputIt must meet the requirements of InputIterator .
|
||
-
OutputIt must meet the requirements of OutputIterator .
|
[edit] Return value
It to the element past the last element written.
[edit] Notes
If first == last
, this function has no effect and will merely return d_first
.
[edit] Complexity
Exactly (last - first) - 1
applications of the binary operation
[edit] Possible implementation
First version |
---|
template<class InputIt, class OutputIt> OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first) { if (first == last) return d_first; typedef typename std::iterator_traits<InputIt>::value_type value_t; value_t acc = *first; *d_first = acc; while (++first != last) { value_t val = *first; *++d_first = val - acc; acc = std::move(val); } return ++d_first; } |
Second version |
template<class InputIt, class OutputIt, class BinaryOperation> OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first, BinaryOperation op) { if (first == last) return d_first; typedef typename std::iterator_traits<InputIt>::value_type value_t; value_t acc = *first; *d_first = acc; while (++first != last) { value_t val = *first; *++d_first = op(val, acc); acc = std::move(val); } return ++d_first; } |
[edit] Example
The following code converts a sequence of even numbers to repetitions of the number 2 and converts a sequence of ones to a sequence of Fibonacci numbers.
#include <numeric> #include <vector> #include <iostream> #include <functional> int main() { std::vector<int> v{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}; std::adjacent_difference(v.begin(), v.end(), v.begin()); for (auto n : v) { std::cout << n << ' '; } std::cout << '\n'; v = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; std::adjacent_difference(v.begin(), v.end() - 1, v.begin() + 1, std::plus<int>()); for (auto n : v) { std::cout << n << ' '; } std::cout << '\n'; }
Output:
2 2 2 2 2 2 2 2 2 2 1 1 2 3 5 8 13 21 34 55
[edit] See also
computes the partial sum of a range of elements (function template) |
|
sums up a range of elements (function template) |
|
(parallelism TS)
|
parallelized version of std::ajacent_difference (function template) |