Init

cppdraft/adjacent/difference.md

@@ -0,0 +1,128 @@
+[adjacent.difference]
+
+# 26 Algorithms library [[algorithms]](./#algorithms)
+
+## 26.10 Generalized numeric operations [[numeric.ops]](numeric.ops#adjacent.difference)
+
+### 26.10.12 Adjacent difference [adjacent.difference]
+
+[🔗](#lib: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);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13139)
+
+Let T be the value type of decltype(first)[.](#1.sentence-1)
+
+For the overloads that do not take an argument binary_op,
+let binary_op be an lvalue
+that denotes an object of type minus<>[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13145)
+
+*Mandates*: 
+
+- [(2.1)](#2.1)
+
+  For the overloads with no ExecutionPolicy, T is constructible from *first[.](#2.1.sentence-1)
+  acc (defined below) is
+ writable ([[iterator.requirements.general]](iterator.requirements.general "24.3.1 General"))
+ to the result output iterator[.](#2.1.sentence-2)
+  The result of the expression binary_op(val, std​::​move(acc)) is writable to result[.](#2.1.sentence-3)
+
+- [(2.2)](#2.2)
+
+  For the overloads with an ExecutionPolicy,
+ the result of the expressions binary_op(*first, *first) and *first are writable to result[.](#2.2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13162)
+
+*Preconditions*: 
+
+- [(3.1)](#3.1)
+
+  For the overloads with no ExecutionPolicy, T meets the [*Cpp17MoveAssignable*](utility.arg.requirements#:Cpp17MoveAssignable "16.4.4.2 Template argument requirements [utility.arg.requirements]") (Table [33](utility.arg.requirements#tab:cpp17.moveassignable "Table 33: Cpp17MoveAssignable requirements"))
+ requirements[.](#3.1.sentence-1)
+
+- [(3.2)](#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[.](#3.2.sentence-1)[209](#footnote-209 "The use of fully closed ranges is intentional.")
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13179)
+
+*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[.](#4.sentence-1)
+
+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[.](#4.sentence-2)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13192)
+
+For the overloads with an ExecutionPolicy and a non-empty range,
+performs *result = *first[.](#5.sentence-1)
+
+Then, for every d in [1, last - first - 1],
+performs *(result + d) = binary_op(*(first + d), *(first + (d - 1)))[.](#5.sentence-2)
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13198)
+
+*Returns*: result + (last - first)[.](#6.sentence-1)
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13202)
+
+*Complexity*: Exactly (last - first) - 1 applications of the binary operation[.](#7.sentence-1)
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/algorithms.tex#L13206)
+
+*Remarks*: For the overloads with no ExecutionPolicy,result may be equal to first[.](#8.sentence-1)
+
+For the overloads with an ExecutionPolicy,
+the ranges [first, last) and [result, result + (last - first))
+shall not overlap[.](#8.sentence-2)
+
+[209)](#footnote-209)[209)](#footnoteref-209)
+
+The use of fully closed ranges is intentional[.](#footnote-209.sentence-1)