26 Algorithms library [algorithms]

26.10 Generalized numeric operations [numeric.ops]

26.10.12 Adjacent difference [adjacent.difference]

template<class InputIterator, class OutputIterator>
  constexpr OutputIterator
    adjacent_difference(InputIterator first, InputIterator last,
                        OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
  ForwardIterator2
    adjacent_difference(ExecutionPolicy&& exec,
                        ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 result);

template<class InputIterator, class OutputIterator, class BinaryOperation>
  constexpr OutputIterator
    adjacent_difference(InputIterator first, InputIterator last,
                        OutputIterator result, BinaryOperation binary_op);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryOperation>
  ForwardIterator2
    adjacent_difference(ExecutionPolicy&& exec,
                        ForwardIterator1 first, ForwardIterator1 last,
                        ForwardIterator2 result, BinaryOperation binary_op);

Let T be the value type of decltype(first).

For the overloads that do not take an argument binary_op, let binary_op be an lvalue that denotes an object of type minus<>.

Mandates:

(2.1)
For the overloads with no ExecutionPolicy, T is constructible from *first.

acc (defined below) is writable ([iterator.requirements.general]) to the result output iterator.

The result of the expression binary_op(val, std::move(acc)) is writable to result.
(2.2)
For the overloads with an ExecutionPolicy, the result of the expressions binary_op(*first, *first) and *first are writable to result.

Preconditions:

(3.1)
For the overloads with no ExecutionPolicy, T meets the Cpp17MoveAssignable (Table 33) requirements.
(3.2)
For all overloads, in the ranges [first, last] and [result, result + (last - first)], binary_op neither modifies elements nor invalidates iterators or subranges.212

Effects: For the overloads with no ExecutionPolicy and a non-empty range, the function creates an accumulator acc of type T, 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 T, initializes it with *i, computes binary_op(val, std::move(acc)), assigns the result to *(result + (i - first)), and move assigns from val to acc.

For the overloads with an ExecutionPolicy and a non-empty range, performs *result = *first.

Then, for every d in [1, last - first - 1], performs *(result + d) = binary_op(*(first + d), *(first + (d - 1))).

Returns: result + (last - first).

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

Remarks: For the overloads with no ExecutionPolicy, result may be equal to first.

For the overloads with an ExecutionPolicy, the ranges [first, last) and [result, result + (last - first)) shall not overlap.

212)212)

The use of fully closed ranges is intentional.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.

26 Algorithms library [algorithms]

26.10 Generalized numeric operations [numeric.ops]

26.10.12 Adjacent difference [adjacent.difference]

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.