[algorithms] - C++11 → C++14

Files changed (1) hide show

tmp/tmpjbelca48/{from.md → to.md} +205 -140

tmp/tmpjbelca48/{from.md → to.md} RENAMED Viewed

@@ -89,26 +89,58 @@ namespace std {
    <class InputIterator1, class InputIterator2, class BinaryPredicate>
     pair<InputIterator1, InputIterator2>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, BinaryPredicate pred);
   template<class InputIterator1, class InputIterator2>
     bool equal(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2);
   template
    <class InputIterator1, class InputIterator2, class BinaryPredicate>
     bool equal(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, BinaryPredicate pred);
   template<class ForwardIterator1, class ForwardIterator2>
     bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2);
   template<class ForwardIterator1, class ForwardIterator2,
                    class BinaryPredicate>
     bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2, BinaryPredicate pred);
   template<class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1 search(
       ForwardIterator1 first1, ForwardIterator1 last1,
       ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ForwardIterator1, class ForwardIterator2,
@@ -120,11 +152,11 @@ namespace std {
   template<class ForwardIterator, class Size, class T>
     ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                              Size count, const T& value);
   template
    <class ForwardIterator, class Size, class T, class BinaryPredicate>
- ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
                              Size count, const T& value,
                              BinaryPredicate pred);
   // [alg.modifying.operations], modifying sequence operations:
   // [alg.copy], copy:
@@ -231,21 +263,24 @@ namespace std {
   template<class ForwardIterator, class OutputIterator>
     OutputIterator rotate_copy(
       ForwardIterator first, ForwardIterator middle,
       ForwardIterator last, OutputIterator result);
   template<class RandomAccessIterator>
     void random_shuffle(RandomAccessIterator first,
                         RandomAccessIterator last);
   template<class RandomAccessIterator, class RandomNumberGenerator>
     void random_shuffle(RandomAccessIterator first,
                         RandomAccessIterator last,
-                        RandomNumberGenerator&& rand);
   template<class RandomAccessIterator, class UniformRandomNumberGenerator>
     void shuffle(RandomAccessIterator first,
                         RandomAccessIterator last,
-                        UniformRandomNumberGenerator&& rand);
   // [alg.partitions], partitions:
   template <class InputIterator, class Predicate>
     bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
@@ -459,33 +494,33 @@ namespace std {
   template<class RandomAccessIterator, class Compare>
     RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                                        Compare comp);
   // [alg.min.max], minimum and maximum:
-  template<class T> const T& min(const T& a, const T& b);
   template<class T, class Compare>
-    const T& min(const T& a, const T& b, Compare comp);
   template<class T>
-    T min(initializer_list<T> t);
   template<class T, class Compare>
-    T min(initializer_list<T> t, Compare comp);
-  template<class T> const T& max(const T& a, const T& b);
   template<class T, class Compare>
-    const T& max(const T& a, const T& b, Compare comp);
   template<class T>
-    T max(initializer_list<T> t);
   template<class T, class Compare>
-    T max(initializer_list<T> t, Compare comp);
-  template<class T> pair<const T&, const T&> minmax(const T& a, const T& b);
   template<class T, class Compare>
-    pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
   template<class T>
-    pair<T, T> minmax(initializer_list<T> t);
   template<class T, class Compare>
-    pair<T, T> minmax(initializer_list<T> t, Compare comp);
   template<class ForwardIterator>
     ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
@@ -537,35 +572,39 @@ the algorithms.
 For purposes of determining the existence of data races, algorithms
 shall not modify objects referenced through an iterator argument unless
 the specification requires such modification.
 Throughout this Clause, the names of template parameters are used to
-express type requirements. If an algorithm’s template parameter is
-`InputIterator`, `InputIterator1`, or `InputIterator2`, the actual
-template argument shall satisfy the requirements of an input iterator (
-[[input.iterators]]). If an algorithm’s template parameter is
-`OutputIterator`, `OutputIterator1`, or `OutputIterator2`, the actual
-template argument shall satisfy the requirements of an output iterator (
-[[output.iterators]]). If an algorithm’s template parameter is
-`ForwardIterator`, `ForwardIterator1`, or `ForwardIterator2`, the actual
-template argument shall satisfy the requirements of a forward iterator (
-[[forward.iterators]]). If an algorithm’s template parameter is
-`BidirectionalIterator`, `BidirectionalIterator1`, or
-`BidirectionalIterator2`, the actual template argument shall satisfy the
-requirements of a bidirectional iterator ([[bidirectional.iterators]]).
-If an algorithm’s template parameter is `RandomAccessIterator`,
-`RandomAccessIterator1`, or `RandomAccessIterator2`, the actual template
   argument shall satisfy the requirements of a random-access iterator (
   [[random.access.iterators]]).
 If an algorithm’s section says that a value pointed to by any iterator
 passed as an argument is modified, then that algorithm has an additional
 type requirement: The type of that argument shall satisfy the
 requirements of a mutable iterator ([[iterator.requirements]]). This
-requirement does not affect arguments that are declared as
-`OutputIterator`, `OutputIterator1`, or `OutputIterator2`, because
-output iterators must always be mutable.
 Both in-place and copying versions are provided for certain
 algorithms.[^1] When such a version is provided for *algorithm* it is
 called *algorithm`_copy`*. Algorithms that take predicates end with the
 suffix `_if` (which follows the suffix `_copy`).
@@ -724,11 +763,11 @@ template<class ForwardIterator1, class ForwardIterator2,
 ```
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The last iterator `i` in the range \[`first1`,
-`last1 - (last2 - first2)`) such that for any non-negative integer
 `n < (last2 - first2)`, the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `last1` if \[`first2`, `last2`) is empty or if no such iterator
 is found.
@@ -813,24 +852,39 @@ template<class InputIterator1, class InputIterator2>
 template<class InputIterator1, class InputIterator2,
           class BinaryPredicate>
   pair<InputIterator1, InputIterator2>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, BinaryPredicate pred);
 ```
 *Returns:* A pair of iterators `i` and `j` such that
 `j == first2 + (i - first1)` and `i` is the first iterator in the range
 \[`first1`, `last1`) for which the following corresponding conditions
 hold:
-``` cpp
-!(*i == *(first2 + (i - first1)))
-pred(*i, *(first2 + (i - first1))) == false
-```
-Returns the pair `last1` and `first2 + (last1 - first1)` if such an
-iterator `i` is not found.
 *Complexity:* At most `last1 - first1` applications of the corresponding
 predicate.
 ### Equal <a id="alg.equal">[[alg.equal]]</a>
@@ -842,19 +896,36 @@ template<class InputIterator1, class InputIterator2>
 template<class InputIterator1, class InputIterator2,
           class BinaryPredicate>
   bool equal(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
 ```
-*Returns:* `true` if for every iterator `i` in the range \[`first1`,
-`last1`) the following corresponding conditions hold:
 `*i == *(first2 + (i - first1)), pred(*i, *(first2 + (i - first1))) != false`.
 Otherwise, returns `false`.
-*Complexity:* At most `last1 - first1` applications of the corresponding
-predicate.
 ### Is permutation <a id="alg.is_permutation">[[alg.is_permutation]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
@@ -862,27 +933,43 @@ template<class ForwardIterator1, class ForwardIterator2>
                       ForwardIterator2 first2);
 template<class ForwardIterator1, class ForwardIterator2,
                  class BinaryPredicate>
   bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                       ForwardIterator2 first2, BinaryPredicate pred);
 ```
-*Requires:* : `ForwardIterator1` and `ForwardIterator2` shall have the
 same value type. The comparison function shall be an equivalence
 relation.
-*Returns:* `true` if there exists a permutation of the elements in the
-range \[`first2`, `first2 + (last1 - first1)`), beginning with
 `ForwardIterator2 begin`, such that `equal(first1, last1, begin)`
 returns `true` or `equal(first1, last1, begin, pred)` returns `true`;
 otherwise, returns `false`.
-*Complexity:* Exactly `distance(first1, last1)` applications of the
-corresponding predicate if `equal(first1, last1, first2)` would return
-`true` or `equal(first1, last1, first2, pred)` would return `true`;
-otherwise, at worst 𝑂(N^2), where N has the value
-`distance(first1, last1)`.
 ### Search <a id="alg.search">[[alg.search]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
@@ -899,11 +986,11 @@ template<class ForwardIterator1, class ForwardIterator2,
 ```
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The first iterator `i` in the range \[`first1`,
-`last1 - (last2-first2)`) such that for any non-negative integer `n`
 less than `last2 - first2` the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `first1` if \[`first2`, `last2`) is empty, otherwise returns
 `last1` if no such iterator is found.
@@ -927,11 +1014,11 @@ template<class ForwardIterator, class Size, class T,
 type ([[conv.integral]], [[class.conv]]).
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The first iterator `i` in the range \[`first`, `last-count`)
-such that for any non-negative integer `n` less than `count` the
 following corresponding conditions hold:
 `*(i + n) == value, pred(*(i + n),value) != false`. Returns `last` if no
 such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
@@ -981,14 +1068,16 @@ template<class InputIterator, class OutputIterator, class Predicate>
 `result + (last - first)`) shall not overlap.
 *Effects:* Copies all of the elements referred to by the iterator `i` in
 the range \[`first`, `last`) for which `pred(*i)` is `true`.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate.
-*Remarks:* Stable.
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
   BidirectionalIterator2
     copy_backward(BidirectionalIterator1 first,
@@ -1236,19 +1325,19 @@ requirements (Table  [[moveassignable]]).
 the range \[`first`, `last`) for which the following corresponding
 conditions hold: `*i == value, pred(*i) != false`.
 *Returns:* The end of the resulting range.
-*Remarks:* Stable.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate.
 *Note:* each element in the range \[`ret`, `last`), where `ret` is the
 returned value, has a valid but unspecified state, because the
-algorithms can eliminate elements by swapping with or moving from
-elements that were originally in that range.
 ``` cpp
 template<class InputIterator, class OutputIterator, class T>
   OutputIterator
     remove_copy(InputIterator first, InputIterator last,
@@ -1260,22 +1349,22 @@ template<class InputIterator, class OutputIterator, class Predicate>
                    OutputIterator result, Predicate pred);
 ```
 *Requires:* The ranges \[`first`, `last`) and \[`result`,
 `result + (last - first)`) shall not overlap. The expression
-`*result = *first` shall ve valid.
 *Effects:* Copies all the elements referred to by the iterator `i` in
 the range \[`first`, `last`) for which the following corresponding
 conditions do not hold: `*i == value, pred(*i) != false`.
 *Returns:* The end of the resulting range.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate.
-*Remarks:* Stable.
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
 ``` cpp
 template<class ForwardIterator>
@@ -1337,13 +1426,12 @@ applications of the corresponding predicate.
 ``` cpp
 template<class BidirectionalIterator>
   void reverse(BidirectionalIterator first, BidirectionalIterator last);
 ```
-*Effects:* For each non-negative integer `i <= (last - first)/2`,
-applies `iter_swap` to all pairs of iterators
-`first + i, (last - i) - 1`.
 *Requires:* `*first` shall be swappable ([[swappable.requirements]]).
 *Complexity:* Exactly `(last - first)/2` swaps.
@@ -1353,13 +1441,13 @@ template<class BidirectionalIterator, class OutputIterator>
     reverse_copy(BidirectionalIterator first,
                  BidirectionalIterator last, OutputIterator result);
 ```
 *Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
-`result+(last-first)`) such that for any non-negative integer
 `i < (last - first)` the following assignment takes place:
-`*(result + (last - first) - i) = *(first + i)`.
 *Requires:* The ranges \[`first`, `last`) and \[`result`,
 `result+(last-first)`) shall not overlap.
 *Returns:* `result + (last - first)`.
@@ -1382,12 +1470,12 @@ the element from the position `first + i` into position
 *Remarks:* This is a left rotate.
 *Requires:* \[`first`, `middle`) and \[`middle`, `last`) shall be valid
 ranges. `ForwardIterator` shall satisfy the requirements of
-ValueSwappable ([[swappable.requirements]]). The type of `*first` shall
-satisfy the requirements of `MoveConstructible`
 (Table  [[moveconstructible]]) and the requirements of `MoveAssignable`
 (Table  [[moveassignable]]).
 *Complexity:* At most `last - first` swaps.
@@ -1408,22 +1496,13 @@ template<class ForwardIterator, class OutputIterator>
 *Requires:* The ranges \[`first`, `last`) and \[`result`,
 `result + (last - first)`) shall not overlap.
 *Complexity:* Exactly `last - first` assignments.
-### Random shuffle <a id="alg.random.shuffle">[[alg.random.shuffle]]</a>
 ``` cpp
-template<class RandomAccessIterator>
-  void random_shuffle(RandomAccessIterator first,
-                      RandomAccessIterator last);
-template<class RandomAccessIterator, class RandomNumberGenerator>
-  void random_shuffle(RandomAccessIterator first,
-                      RandomAccessIterator last,
-                      RandomNumberGenerator&& rand);
 template<class RandomAccessIterator, class UniformRandomNumberGenerator>
   void shuffle(RandomAccessIterator first,
                       RandomAccessIterator last,
                       UniformRandomNumberGenerator&& g);
 ```
@@ -1431,35 +1510,20 @@ template<class RandomAccessIterator, class UniformRandomNumberGenerator>
 *Effects:* Permutes the elements in the range \[`first`, `last`) such
 that each possible permutation of those elements has equal probability
 of appearance.
 *Requires:* `RandomAccessIterator` shall satisfy the requirements of
-`ValueSwappable` ([[swappable.requirements]]). The random number
-generating function object `rand` shall have a return type that is
-convertible to `iterator_traits<RandomAccessIterator>::difference_type`,
-and the call `rand(n)` shall return a randomly chosen value in the
-interval \[`0`, `n`), for `n > 0` of type
-`iterator_traits<RandomAccessIterator>::difference_type`. The type
 `UniformRandomNumberGenerator` shall meet the requirements of a uniform
 random number generator ([[rand.req.urng]]) type whose return type is
 convertible to `iterator_traits<RandomAccessIterator>::difference_type`.
 *Complexity:* Exactly `(last - first) - 1` swaps.
-*Remarks:* To the extent that the implementation of these functions
-makes use of random numbers, the implementation shall use the following
-sources of randomness:
-The underlying source of random numbers for the first form of the
-function is *implementation-defined*. An implementation may use the
-`rand` function from the standard C library.
-In the second form of the function, the function object `rand` shall
-serve as the implementation’s source of randomness.
-In the third `shuffle` form of the function, the object `g` shall serve
-as the implementation’s source of randomness.
 ### Partitions <a id="alg.partitions">[[alg.partitions]]</a>
 ``` cpp
 template <class InputIterator, class Predicate>
@@ -1483,12 +1547,12 @@ template<class ForwardIterator, class Predicate>
 ```
 *Effects:* Places all the elements in the range \[`first`, `last`) that
 satisfy `pred` before all the elements that do not satisfy it.
-*Returns:* An iterator `i` such that for any iterator `j` in the range
-\[`first`, `i`) `pred(*j) != false`, and for any iterator `k` in the
 range \[`i`, `last`), `pred(*k) == false`.
 *Requires:* `ForwardIterator` shall satisfy the requirements of
 `ValueSwappable` ([[swappable.requirements]]).
@@ -1505,12 +1569,12 @@ template<class BidirectionalIterator, class Predicate>
 ```
 *Effects:* Places all the elements in the range \[`first`, `last`) that
 satisfy `pred` before all the elements that do not satisfy it.
-*Returns:* An iterator `i` such that for any iterator `j` in the range
-\[`first`, `i`), `pred(*j) != false`, and for any iterator `k` in the
 range \[`i`, `last`), `pred(*k) == false`. The relative order of the
 elements in both groups is preserved.
 *Requires:* `BidirectionalIterator` shall satisfy the requirements of
 `ValueSwappable` ([[swappable.requirements]]). The type of `*first`
@@ -1529,13 +1593,13 @@ template <class InputIterator, class OutputIterator1,
   partition_copy(InputIterator first, InputIterator last,
                  OutputIterator1 out_true, OutputIterator2 out_false,
                  Predicate pred);
 ```
-*Requires:* `InputIterator`’s value type shall be Assignable, and shall
-be writable to the `out_true` and `out_false` `OutputIterator`s, and
-shall be convertible to `Predicate`’s argument type. The input range
 shall not overlap with either of the output ranges.
 *Effects:* For each iterator `i` in \[`first`, `last`), copies `*i` to
 the output range beginning with `out_true` if `pred(*i)` is `true`, or
 to the output range beginning with `out_false` otherwise.
@@ -1570,15 +1634,15 @@ a function object of type `Compare` and one that uses an `operator<`.
 `Compare`
 is a function object type ([[function.objects]]). The return value of
 the function call operation applied to an object of type `Compare`, when
-contextually converted to `bool` ([[conv]]), yields `true` if the first
-argument of the call is less than the second, and `false` otherwise.
-`Compare comp` is used throughout for algorithms assuming an ordering
-relation. It is assumed that `comp` will not apply any non-constant
-function through the dereferenced iterator.
 For all algorithms that take `Compare`, there is a version that uses
 `operator<` instead. That is, `comp(*i, *j) != false` defaults to
 `*i < *j != false`. For algorithms other than those described in
 [[alg.binary.search]] to work correctly, `comp` has to induce a strict
@@ -1597,12 +1661,12 @@ for a partial ordering. If we define `equiv(a, b)` as
   - `equiv` is an equivalence relation
   - `comp` induces a well-defined relation on the equivalence classes
     determined by `equiv`
   - The induced relation is a strict total ordering.
-A sequence is *sorted with respect to a comparator* `comp` if for any
-iterator `i` pointing to the sequence and any non-negative integer `n`
 such that `i + n` is a valid iterator pointing to an element of the
 sequence, `comp(*(i + n), *i) == false`.
 A sequence \[`start`, `finish`) is *partitioned with respect to an
 expression* `f(e)` if there exists an integer `n` such that for all
@@ -1659,11 +1723,11 @@ shall satisfy the requirements of `MoveConstructible`
 (Table  [[moveassignable]]).
 *Complexity:* It does at most N log²(N) (where N` == last - first`)
 comparisons; if enough extra memory is available, it is N log(N).
-*Remarks:* Stable.
 #### `partial_sort` <a id="partial.sort">[[partial.sort]]</a>
 ``` cpp
 template<class RandomAccessIterator>
@@ -1771,13 +1835,13 @@ template<class RandomAccessIterator, class Compare>
                    RandomAccessIterator last,  Compare comp);
 ```
 After `nth_element` the element in the position pointed to by `nth` is
 the element that would be in that position if the whole range were
-sorted. Also for any iterator `i` in the range \[`first`, `nth`) and any
-iterator `j` in the range \[`nth`, `last`) it holds that: `!(*i > *j)`
-or `comp(*j, *i) == false`.
 *Requires:* `RandomAccessIterator` shall satisfy the requirements of
 `ValueSwappable` ([[swappable.requirements]]). The type of `*first`
 shall satisfy the requirements of `MoveConstructible`
 (Table  [[moveconstructible]]) and of `MoveAssignable`
@@ -1813,15 +1877,15 @@ template<class ForwardIterator, class T, class Compare>
 *Requires:* The elements `e` of \[`first`, `last`) shall be partitioned
 with respect to the expression `e < value` or `comp(e, value)`.
 *Returns:* The furthermost iterator `i` in the range \[`first`, `last`\]
-such that for any iterator `j` in the range \[`first`, `i`) the
 following corresponding conditions hold: `*j < value` or
 `comp(*j, value) != false`.
-*Complexity:* At most log₂(last - first) + 𝑂(1) comparisons.
 #### `upper_bound` <a id="upper.bound">[[upper.bound]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
@@ -1837,15 +1901,15 @@ template<class ForwardIterator, class T, class Compare>
 *Requires:* The elements `e` of \[`first`, `last`) shall be partitioned
 with respect to the expression `!(value < e)` or `!comp(value, e)`.
 *Returns:* The furthermost iterator `i` in the range \[`first`, `last`\]
-such that for any iterator `j` in the range \[`first`, `i`) the
 following corresponding conditions hold: `!(value < *j)` or
 `comp(value, *j) == false`.
-*Complexity:* At most log₂(last - first) + 𝑂(1) comparisons.
 #### `equal_range` <a id="equal.range">[[equal.range]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
@@ -1878,11 +1942,11 @@ or
 ``` cpp
 make_pair(lower_bound(first, last, value, comp),
           upper_bound(first, last, value, comp))
 ```
-*Complexity:* At most 2 * log₂(last - first) + 𝑂(1) comparisons.
 #### `binary_search` <a id="binary.search">[[binary.search]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
@@ -1903,11 +1967,11 @@ implies `!comp(value, e)`.
 *Returns:* `true` if there is an iterator `i` in the range \[`first`,
 `last`) that satisfies the corresponding conditions:
 `!(*i < value) && !(value < *i)` or
 `comp(*i, value) == false && comp(value, *i) == false`.
-*Complexity:* At most `log2(last - first)` + 𝑂(1) comparisons.
 ### Merge <a id="alg.merge">[[alg.merge]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2,
@@ -1939,11 +2003,11 @@ range shall not overlap with either of the original ranges.
 *Returns:* `result + (last1 - first1) + (last2 - first2)`.
 *Complexity:* At most `(last1 - first1) + (last2 - first2) - 1`
 comparisons.
-*Remarks:* Stable.
 ``` cpp
 template<class BidirectionalIterator>
   void inplace_merge(BidirectionalIterator first,
                      BidirectionalIterator middle,
@@ -1973,11 +2037,11 @@ shall satisfy the requirements of `MoveConstructible`
 *Complexity:* When enough additional memory is available,
 `(last - first) - 1` comparisons. If no additional memory is available,
 an algorithm with complexity N log(N) (where `N` is equal to
 `last - first`) may be used.
-*Remarks:* Stable.
 ### Set operations on sorted structures <a id="alg.set.operations">[[alg.set.operations]]</a>
 This section defines all the basic set operations on sorted structures.
 They also work with `multiset`s ([[multiset]]) containing multiple
@@ -2293,13 +2357,13 @@ returns the last iterator `i` in \[`first`, `last`\] for which the range
 *Complexity:* Linear.
 ### Minimum and maximum <a id="alg.min.max">[[alg.min.max]]</a>
 ``` cpp
-template<class T> const T& min(const T& a, const T& b);
 template<class T, class Compare>
-  const T& min(const T& a, const T& b, Compare comp);
 ```
 *Requires:* Type `T` is `LessThanComparable`
 (Table  [[lessthancomparable]]).
@@ -2307,13 +2371,13 @@ template<class T, class Compare>
 *Remarks:* Returns the first argument when the arguments are equivalent.
 ``` cpp
 template<class T>
-  T min(initializer_list<T> t);
 template<class T, class Compare>
-  T min(initializer_list<T> t, Compare comp);
 ```
 *Requires:* `T` is `LessThanComparable` and `CopyConstructible` and
 `t.size() > 0`.
@@ -2321,13 +2385,13 @@ template<class T, class Compare>
 *Remarks:* Returns a copy of the leftmost argument when several
 arguments are equivalent to the smallest.
 ``` cpp
-template<class T> const T& max(const T& a, const T& b);
 template<class T, class Compare>
-  const T& max(const T& a, const T& b, Compare comp);
 ```
 *Requires:* Type `T` is `LessThanComparable`
 (Table  [[lessthancomparable]]).
@@ -2335,13 +2399,13 @@ template<class T, class Compare>
 *Remarks:* Returns the first argument when the arguments are equivalent.
 ``` cpp
 template<class T>
-  T max(initializer_list<T> t);
 template<class T, class Compare>
-  T max(initializer_list<T> t, Compare comp);
 ```
 *Requires:* `T` is `LessThanComparable` and `CopyConstructible` and
 `t.size() > 0`.
@@ -2349,13 +2413,13 @@ template<class T, class Compare>
 *Remarks:* Returns a copy of the leftmost argument when several
 arguments are equivalent to the largest.
 ``` cpp
-template<class T> pair<const T&, const T&> minmax(const T& a, const T& b);
 template<class T, class Compare>
-  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
 ```
 *Requires:* Type `T` shall be `LessThanComparable`
 (Table  [[lessthancomparable]]).
@@ -2367,13 +2431,13 @@ are equivalent.
 *Complexity:* Exactly one comparison.
 ``` cpp
 template<class T>
-  pair<T, T> minmax(initializer_list<T> t);
 template<class T, class Compare>
-  pair<T, T> minmax(initializer_list<T> t, Compare comp);
 ```
 *Requires:* `T` is `LessThanComparable` and `CopyConstructible` and
 `t.size() > 0`.
@@ -2395,13 +2459,13 @@ template<class ForwardIterator, class Compare>
   ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                             Compare comp);
 ```
 *Returns:* The first iterator `i` in the range \[`first`, `last`) such
-that for any iterator `j` in the range \[`first`, `last`) the following
-corresponding conditions hold: `!(*j < *i)` or `comp(*j, *i) == false`.
-Returns `last` if `first == last`.
 *Complexity:* Exactly `max((last - first) - 1, 0)` applications of the
 corresponding comparisons.
 ``` cpp
@@ -2411,13 +2475,13 @@ template<class ForwardIterator, class Compare>
   ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                             Compare comp);
 ```
 *Returns:* The first iterator `i` in the range \[`first`, `last`) such
-that for any iterator `j` in the range \[`first`, `last`) the following
-corresponding conditions hold: `!(*i < *j)` or `comp(*i, *j) == false`.
-Returns `last` if `first == last`.
 *Complexity:* Exactly `max((last - first) - 1, 0)` applications of the
 corresponding comparisons.
 ``` cpp
@@ -2620,10 +2684,11 @@ ISO C 7.10.5.
 [alg.sort]: #alg.sort
 [alg.sorting]: #alg.sorting
 [alg.swap]: #alg.swap
 [alg.transform]: #alg.transform
 [alg.unique]: #alg.unique
 [algorithms]: #algorithms
 [algorithms.general]: #algorithms.general
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [binary.search]: #binary.search
 [class.conv]: special.md#class.conv

    <class InputIterator1, class InputIterator2, class BinaryPredicate>
     pair<InputIterator1, InputIterator2>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, BinaryPredicate pred);
+  template<class InputIterator1, class InputIterator2>
+    pair<InputIterator1, InputIterator2>
+      mismatch(InputIterator1 first1, InputIterator1 last1,
+               InputIterator2 first2, InputIterator2 last2);
+  template
+   <class InputIterator1, class InputIterator2, class BinaryPredicate>
+    pair<InputIterator1, InputIterator2>
+      mismatch(InputIterator1 first1, InputIterator1 last1,
+               InputIterator2 first2, InputIterator2 last2,
+               BinaryPredicate pred);
   template<class InputIterator1, class InputIterator2>
     bool equal(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2);
   template
    <class InputIterator1, class InputIterator2, class BinaryPredicate>
     bool equal(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, BinaryPredicate pred);
+  template<class InputIterator1, class InputIterator2>
+    bool equal(InputIterator1 first1, InputIterator1 last1,
+               InputIterator2 first2, InputIterator2 last2);
+  template
+   <class InputIterator1, class InputIterator2, class BinaryPredicate>
+    bool equal(InputIterator1 first1, InputIterator1 last1,
+               InputIterator2 first2, InputIterator2 last2,
+               BinaryPredicate pred);
   template<class ForwardIterator1, class ForwardIterator2>
     bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2);
   template<class ForwardIterator1, class ForwardIterator2,
                    class BinaryPredicate>
     bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2, BinaryPredicate pred);
+  template<class ForwardIterator1, class ForwardIterator2>
+    bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
+                        ForwardIterator2 first2, ForwardIterator2 last2);
+  template<class ForwardIterator1, class ForwardIterator2,
+                      class BinaryPredicate>
+    bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
+                        ForwardIterator2 first2, ForwardIterator2 last2,
+                        BinaryPredicate pred);
   template<class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1 search(
       ForwardIterator1 first1, ForwardIterator1 last1,
       ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ForwardIterator1, class ForwardIterator2,
   template<class ForwardIterator, class Size, class T>
     ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                              Size count, const T& value);
   template
    <class ForwardIterator, class Size, class T, class BinaryPredicate>
+ ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                              Size count, const T& value,
                              BinaryPredicate pred);
   // [alg.modifying.operations], modifying sequence operations:
   // [alg.copy], copy:
   template<class ForwardIterator, class OutputIterator>
     OutputIterator rotate_copy(
       ForwardIterator first, ForwardIterator middle,
       ForwardIterator last, OutputIterator result);
+  // [depr.alg.random.shuffle], random_shuffle (deprecated):
   template<class RandomAccessIterator>
     void random_shuffle(RandomAccessIterator first,
                         RandomAccessIterator last);
   template<class RandomAccessIterator, class RandomNumberGenerator>
     void random_shuffle(RandomAccessIterator first,
                         RandomAccessIterator last,
+                        RandomNumberGenerator&& rng);
+  // [alg.random.shuffle], shuffle:
   template<class RandomAccessIterator, class UniformRandomNumberGenerator>
     void shuffle(RandomAccessIterator first,
                         RandomAccessIterator last,
+                        UniformRandomNumberGenerator&& g);
   // [alg.partitions], partitions:
   template <class InputIterator, class Predicate>
     bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
   template<class RandomAccessIterator, class Compare>
     RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                                        Compare comp);
   // [alg.min.max], minimum and maximum:
+  template<class T> constexpr const T& min(const T& a, const T& b);
   template<class T, class Compare>
+ constexpr const T& min(const T& a, const T& b, Compare comp);
   template<class T>
+ constexpr T min(initializer_list<T> t);
   template<class T, class Compare>
+ constexpr T min(initializer_list<T> t, Compare comp);
+  template<class T> constexpr const T& max(const T& a, const T& b);
   template<class T, class Compare>
+ constexpr const T& max(const T& a, const T& b, Compare comp);
   template<class T>
+ constexpr T max(initializer_list<T> t);
   template<class T, class Compare>
+ constexpr T max(initializer_list<T> t, Compare comp);
+  template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
   template<class T, class Compare>
+ constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
   template<class T>
+ constexpr pair<T, T> minmax(initializer_list<T> t);
   template<class T, class Compare>
+ constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
   template<class ForwardIterator>
     ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
 For purposes of determining the existence of data races, algorithms
 shall not modify objects referenced through an iterator argument unless
 the specification requires such modification.
 Throughout this Clause, the names of template parameters are used to
+express type requirements.
+- If an algorithm’s template parameter is named `InputIterator`,
+  `InputIterator1`, or `InputIterator2`, the template argument shall
+  satisfy the requirements of an input iterator ([[input.iterators]]).
+- If an algorithm’s template parameter is named `OutputIterator`,
+  `OutputIterator1`, or `OutputIterator2`, the template argument shall
+  satisfy the requirements of an output iterator (
+  [[output.iterators]]).
+- If an algorithm’s template parameter is named `ForwardIterator`,
+ `ForwardIterator1`, or `ForwardIterator2`, the template argument shall
+  satisfy the requirements of a forward iterator (
+ [[forward.iterators]]).
+- If an algorithm’s template parameter is named `BidirectionalIterator`,
+ `BidirectionalIterator1`, or `BidirectionalIterator2`, the template
+  argument shall satisfy the requirements of a bidirectional iterator (
+  [[bidirectional.iterators]]).
+- If an algorithm’s template parameter is named `RandomAccessIterator`,
+  `RandomAccessIterator1`, or `RandomAccessIterator2`, the template
   argument shall satisfy the requirements of a random-access iterator (
   [[random.access.iterators]]).
 If an algorithm’s section says that a value pointed to by any iterator
 passed as an argument is modified, then that algorithm has an additional
 type requirement: The type of that argument shall satisfy the
 requirements of a mutable iterator ([[iterator.requirements]]). This
+requirement does not affect arguments that are named `OutputIterator`,
+`OutputIterator1`, or `OutputIterator2`, because output iterators must
+always be mutable.
 Both in-place and copying versions are provided for certain
 algorithms.[^1] When such a version is provided for *algorithm* it is
 called *algorithm`_copy`*. Algorithms that take predicates end with the
 suffix `_if` (which follows the suffix `_copy`).
 ```
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The last iterator `i` in the range \[`first1`,
+`last1 - (last2 - first2)`) such that for every non-negative integer
 `n < (last2 - first2)`, the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `last1` if \[`first2`, `last2`) is empty or if no such iterator
 is found.
 template<class InputIterator1, class InputIterator2,
           class BinaryPredicate>
   pair<InputIterator1, InputIterator2>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, BinaryPredicate pred);
+template<class InputIterator1, class InputIterator2>
+  pair<InputIterator1, InputIterator2>
+    mismatch(InputIterator1 first1, InputIterator1 last1,
+             InputIterator2 first2, InputIterator2 last2);
+template <class InputIterator1, class InputIterator2,
+           class BinaryPredicate>
+  pair<InputIterator1, InputIterator2>
+    mismatch(InputIterator1 first1, InputIterator1 last1,
+             InputIterator2 first2, InputIterator2 last2,
+             BinaryPredicate pred);
 ```
+*Remarks:* If `last2` was not given in the argument list, it denotes
+`first2 + (last1 - first1)` below.
 *Returns:* A pair of iterators `i` and `j` such that
 `j == first2 + (i - first1)` and `i` is the first iterator in the range
 \[`first1`, `last1`) for which the following corresponding conditions
 hold:
+- `j` is in the range `[first2, last2)`.
+- `!(*i == *(first2 + (i - first1)))`
+- `pred(*i, *(first2 + (i - first1))) == false`
+Returns the pair `first1 + min(last1 - first1, last2 - first2)` and
+`first2 + min(last1 - first1, last2 - first2)` if such an iterator `i`
+is not found.
 *Complexity:* At most `last1 - first1` applications of the corresponding
 predicate.
 ### Equal <a id="alg.equal">[[alg.equal]]</a>
 template<class InputIterator1, class InputIterator2,
           class BinaryPredicate>
   bool equal(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
+template<class InputIterator1, class InputIterator2>
+  bool equal(InputIterator1 first1, InputIterator1 last1,
+             InputIterator2 first2, InputIterator2 last2);
+template<class InputIterator1, class InputIterator2,
+           class BinaryPredicate>
+  bool equal(InputIterator1 first1, InputIterator1 last1,
+             InputIterator2 first2, InputIterator2 last2,
+             BinaryPredicate pred);
 ```
+*Remarks:* If `last2` was not given in the argument list, it denotes
+`first2 + (last1 - first1)` below.
+*Returns:* If `last1 - first1 != last2 - first2`, return `false`.
+Otherwise return `true` if for every iterator `i` in the range
+\[`first1`, `last1`) the following corresponding conditions hold:
 `*i == *(first2 + (i - first1)), pred(*i, *(first2 + (i - first1))) != false`.
 Otherwise, returns `false`.
+*Complexity:* No applications of the corresponding predicate if
+`InputIterator1` and `InputIterator2` meet the requirements of random
+access iterators and `last1 - first1 != last2 - first2`. Otherwise, at
+most `min(last1 - first1, last2 - first2)` applications of the
+corresponding predicate.
 ### Is permutation <a id="alg.is_permutation">[[alg.is_permutation]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
                       ForwardIterator2 first2);
 template<class ForwardIterator1, class ForwardIterator2,
                  class BinaryPredicate>
   bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                       ForwardIterator2 first2, BinaryPredicate pred);
+template<class ForwardIterator1, class ForwardIterator2>
+  bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
+                      ForwardIterator2 first2, ForwardIterator2 last2);
+template<class ForwardIterator1, class ForwardIterator2,
+                 class BinaryPredicate>
+  bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
+                      ForwardIterator2 first2, ForwardIterator2 last2,
+                      BinaryPredicate pred);
 ```
+*Requires:* `ForwardIterator1` and `ForwardIterator2` shall have the
 same value type. The comparison function shall be an equivalence
 relation.
+*Remarks:* If `last2` was not given in the argument list, it denotes
+`first2 + (last1 - first1)` below.
+*Returns:* If `last1 - first1 != last2 - first2`, return `false`.
+Otherwise return `true` if there exists a permutation of the elements in
+the range \[`first2`, `first2 + (last1 - first1)`), beginning with
 `ForwardIterator2 begin`, such that `equal(first1, last1, begin)`
 returns `true` or `equal(first1, last1, begin, pred)` returns `true`;
 otherwise, returns `false`.
+*Complexity:* No applications of the corresponding predicate if
+`ForwardIterator1` and `ForwardIterator2` meet the requirements of
+random access iterators and `last1 - first1 != last2 - first2`.
+Otherwise, exactly `distance(first1, last1)` applications of the
+corresponding predicate if `equal(first1, last1, first2, last2)` would
+return `true` if `pred` was not given in the argument list or
+`equal(first1, last1, first2, last2, pred)` would return `true` if pred
+was given in the argument list; otherwise, at worst 𝑂(N^2), where N has
+the value `distance(first1, last1)`.
 ### Search <a id="alg.search">[[alg.search]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
 ```
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The first iterator `i` in the range \[`first1`,
+`last1 - (last2-first2)`) such that for every non-negative integer `n`
 less than `last2 - first2` the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `first1` if \[`first2`, `last2`) is empty, otherwise returns
 `last1` if no such iterator is found.
 type ([[conv.integral]], [[class.conv]]).
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The first iterator `i` in the range \[`first`, `last-count`)
+such that for every non-negative integer `n` less than `count` the
 following corresponding conditions hold:
 `*(i + n) == value, pred(*(i + n),value) != false`. Returns `last` if no
 such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 `result + (last - first)`) shall not overlap.
 *Effects:* Copies all of the elements referred to by the iterator `i` in
 the range \[`first`, `last`) for which `pred(*i)` is `true`.
+*Returns:* The end of the resulting range.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate.
+*Remarks:* Stable ([[algorithm.stable]]).
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
   BidirectionalIterator2
     copy_backward(BidirectionalIterator1 first,
 the range \[`first`, `last`) for which the following corresponding
 conditions hold: `*i == value, pred(*i) != false`.
 *Returns:* The end of the resulting range.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate.
 *Note:* each element in the range \[`ret`, `last`), where `ret` is the
 returned value, has a valid but unspecified state, because the
+algorithms can eliminate elements by moving from elements that were
+originally in that range.
 ``` cpp
 template<class InputIterator, class OutputIterator, class T>
   OutputIterator
     remove_copy(InputIterator first, InputIterator last,
                    OutputIterator result, Predicate pred);
 ```
 *Requires:* The ranges \[`first`, `last`) and \[`result`,
 `result + (last - first)`) shall not overlap. The expression
+`*result = *first` shall be valid.
 *Effects:* Copies all the elements referred to by the iterator `i` in
 the range \[`first`, `last`) for which the following corresponding
 conditions do not hold: `*i == value, pred(*i) != false`.
 *Returns:* The end of the resulting range.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate.
+*Remarks:* Stable ([[algorithm.stable]]).
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
 ``` cpp
 template<class ForwardIterator>
 ``` cpp
 template<class BidirectionalIterator>
   void reverse(BidirectionalIterator first, BidirectionalIterator last);
 ```
+*Effects:* For each non-negative integer `i < (last - first)/2`, applies
+`iter_swap` to all pairs of iterators `first + i, (last - i) - 1`.
 *Requires:* `*first` shall be swappable ([[swappable.requirements]]).
 *Complexity:* Exactly `(last - first)/2` swaps.
     reverse_copy(BidirectionalIterator first,
                  BidirectionalIterator last, OutputIterator result);
 ```
 *Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
+`result+(last-first)`) such that for every non-negative integer
 `i < (last - first)` the following assignment takes place:
+`*(result + (last - first) - 1 - i) = *(first + i)`.
 *Requires:* The ranges \[`first`, `last`) and \[`result`,
 `result+(last-first)`) shall not overlap.
 *Returns:* `result + (last - first)`.
 *Remarks:* This is a left rotate.
 *Requires:* \[`first`, `middle`) and \[`middle`, `last`) shall be valid
 ranges. `ForwardIterator` shall satisfy the requirements of
+`ValueSwappable` ([[swappable.requirements]]). The type of `*first`
+shall satisfy the requirements of `MoveConstructible`
 (Table  [[moveconstructible]]) and the requirements of `MoveAssignable`
 (Table  [[moveassignable]]).
 *Complexity:* At most `last - first` swaps.
 *Requires:* The ranges \[`first`, `last`) and \[`result`,
 `result + (last - first)`) shall not overlap.
 *Complexity:* Exactly `last - first` assignments.
+### Shuffle <a id="alg.random.shuffle">[[alg.random.shuffle]]</a>
 ``` cpp
 template<class RandomAccessIterator, class UniformRandomNumberGenerator>
   void shuffle(RandomAccessIterator first,
                       RandomAccessIterator last,
                       UniformRandomNumberGenerator&& g);
 ```
 *Effects:* Permutes the elements in the range \[`first`, `last`) such
 that each possible permutation of those elements has equal probability
 of appearance.
 *Requires:* `RandomAccessIterator` shall satisfy the requirements of
+`ValueSwappable` ([[swappable.requirements]]). The type
 `UniformRandomNumberGenerator` shall meet the requirements of a uniform
 random number generator ([[rand.req.urng]]) type whose return type is
 convertible to `iterator_traits<RandomAccessIterator>::difference_type`.
 *Complexity:* Exactly `(last - first) - 1` swaps.
+*Remarks:* To the extent that the implementation of this function makes
+use of random numbers, the object `g` shall serve as the
+implementation’s source of randomness.
 ### Partitions <a id="alg.partitions">[[alg.partitions]]</a>
 ``` cpp
 template <class InputIterator, class Predicate>
 ```
 *Effects:* Places all the elements in the range \[`first`, `last`) that
 satisfy `pred` before all the elements that do not satisfy it.
+*Returns:* An iterator `i` such that for every iterator `j` in the range
+\[`first`, `i`) `pred(*j) != false`, and for every iterator `k` in the
 range \[`i`, `last`), `pred(*k) == false`.
 *Requires:* `ForwardIterator` shall satisfy the requirements of
 `ValueSwappable` ([[swappable.requirements]]).
 ```
 *Effects:* Places all the elements in the range \[`first`, `last`) that
 satisfy `pred` before all the elements that do not satisfy it.
+*Returns:* An iterator `i` such that for every iterator `j` in the range
+\[`first`, `i`), `pred(*j) != false`, and for every iterator `k` in the
 range \[`i`, `last`), `pred(*k) == false`. The relative order of the
 elements in both groups is preserved.
 *Requires:* `BidirectionalIterator` shall satisfy the requirements of
 `ValueSwappable` ([[swappable.requirements]]). The type of `*first`
   partition_copy(InputIterator first, InputIterator last,
                  OutputIterator1 out_true, OutputIterator2 out_false,
                  Predicate pred);
 ```
+*Requires:* `InputIterator`’s value type shall be `CopyAssignable`, and
+shall be writable to the `out_true` and `out_false` `OutputIterator`s,
+and shall be convertible to `Predicate`’s argument type. The input range
 shall not overlap with either of the output ranges.
 *Effects:* For each iterator `i` in \[`first`, `last`), copies `*i` to
 the output range beginning with `out_true` if `pred(*i)` is `true`, or
 to the output range beginning with `out_false` otherwise.
 `Compare`
 is a function object type ([[function.objects]]). The return value of
 the function call operation applied to an object of type `Compare`, when
+contextually converted to `bool` (Clause  [[conv]]), yields `true` if
+the first argument of the call is less than the second, and `false`
+otherwise. `Compare comp` is used throughout for algorithms assuming an
+ordering relation. It is assumed that `comp` will not apply any
+non-constant function through the dereferenced iterator.
 For all algorithms that take `Compare`, there is a version that uses
 `operator<` instead. That is, `comp(*i, *j) != false` defaults to
 `*i < *j != false`. For algorithms other than those described in
 [[alg.binary.search]] to work correctly, `comp` has to induce a strict
   - `equiv` is an equivalence relation
   - `comp` induces a well-defined relation on the equivalence classes
     determined by `equiv`
   - The induced relation is a strict total ordering.
+A sequence is *sorted with respect to a comparator* `comp` if for every
+iterator `i` pointing to the sequence and every non-negative integer `n`
 such that `i + n` is a valid iterator pointing to an element of the
 sequence, `comp(*(i + n), *i) == false`.
 A sequence \[`start`, `finish`) is *partitioned with respect to an
 expression* `f(e)` if there exists an integer `n` such that for all
 (Table  [[moveassignable]]).
 *Complexity:* It does at most N log²(N) (where N` == last - first`)
 comparisons; if enough extra memory is available, it is N log(N).
+*Remarks:* Stable ([[algorithm.stable]]).
 #### `partial_sort` <a id="partial.sort">[[partial.sort]]</a>
 ``` cpp
 template<class RandomAccessIterator>
                    RandomAccessIterator last,  Compare comp);
 ```
 After `nth_element` the element in the position pointed to by `nth` is
 the element that would be in that position if the whole range were
+sorted, unless `nth == last`. Also for every iterator `i` in the range
+\[`first`, `nth`) and every iterator `j` in the range \[`nth`, `last`)
+it holds that: `!(*j < *i)` or `comp(*j, *i) == false`.
 *Requires:* `RandomAccessIterator` shall satisfy the requirements of
 `ValueSwappable` ([[swappable.requirements]]). The type of `*first`
 shall satisfy the requirements of `MoveConstructible`
 (Table  [[moveconstructible]]) and of `MoveAssignable`
 *Requires:* The elements `e` of \[`first`, `last`) shall be partitioned
 with respect to the expression `e < value` or `comp(e, value)`.
 *Returns:* The furthermost iterator `i` in the range \[`first`, `last`\]
+such that for every iterator `j` in the range \[`first`, `i`) the
 following corresponding conditions hold: `*j < value` or
 `comp(*j, value) != false`.
+*Complexity:* At most log₂(`last - first`) + 𝑂(1) comparisons.
 #### `upper_bound` <a id="upper.bound">[[upper.bound]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
 *Requires:* The elements `e` of \[`first`, `last`) shall be partitioned
 with respect to the expression `!(value < e)` or `!comp(value, e)`.
 *Returns:* The furthermost iterator `i` in the range \[`first`, `last`\]
+such that for every iterator `j` in the range \[`first`, `i`) the
 following corresponding conditions hold: `!(value < *j)` or
 `comp(value, *j) == false`.
+*Complexity:* At most log₂(`last - first`) + 𝑂(1) comparisons.
 #### `equal_range` <a id="equal.range">[[equal.range]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
 ``` cpp
 make_pair(lower_bound(first, last, value, comp),
           upper_bound(first, last, value, comp))
 ```
+*Complexity:* At most 2 * log₂(`last - first`) + 𝑂(1) comparisons.
 #### `binary_search` <a id="binary.search">[[binary.search]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
 *Returns:* `true` if there is an iterator `i` in the range \[`first`,
 `last`) that satisfies the corresponding conditions:
 `!(*i < value) && !(value < *i)` or
 `comp(*i, value) == false && comp(value, *i) == false`.
+*Complexity:* At most log₂(`last - first`) + 𝑂(1) comparisons.
 ### Merge <a id="alg.merge">[[alg.merge]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2,
 *Returns:* `result + (last1 - first1) + (last2 - first2)`.
 *Complexity:* At most `(last1 - first1) + (last2 - first2) - 1`
 comparisons.
+*Remarks:* Stable ([[algorithm.stable]]).
 ``` cpp
 template<class BidirectionalIterator>
   void inplace_merge(BidirectionalIterator first,
                      BidirectionalIterator middle,
 *Complexity:* When enough additional memory is available,
 `(last - first) - 1` comparisons. If no additional memory is available,
 an algorithm with complexity N log(N) (where `N` is equal to
 `last - first`) may be used.
+*Remarks:* Stable ([[algorithm.stable]]).
 ### Set operations on sorted structures <a id="alg.set.operations">[[alg.set.operations]]</a>
 This section defines all the basic set operations on sorted structures.
 They also work with `multiset`s ([[multiset]]) containing multiple
 *Complexity:* Linear.
 ### Minimum and maximum <a id="alg.min.max">[[alg.min.max]]</a>
 ``` cpp
+template<class T> constexpr const T& min(const T& a, const T& b);
 template<class T, class Compare>
+ constexpr const T& min(const T& a, const T& b, Compare comp);
 ```
 *Requires:* Type `T` is `LessThanComparable`
 (Table  [[lessthancomparable]]).
 *Remarks:* Returns the first argument when the arguments are equivalent.
 ``` cpp
 template<class T>
+ constexpr T min(initializer_list<T> t);
 template<class T, class Compare>
+ constexpr T min(initializer_list<T> t, Compare comp);
 ```
 *Requires:* `T` is `LessThanComparable` and `CopyConstructible` and
 `t.size() > 0`.
 *Remarks:* Returns a copy of the leftmost argument when several
 arguments are equivalent to the smallest.
 ``` cpp
+template<class T> constexpr const T& max(const T& a, const T& b);
 template<class T, class Compare>
+ constexpr const T& max(const T& a, const T& b, Compare comp);
 ```
 *Requires:* Type `T` is `LessThanComparable`
 (Table  [[lessthancomparable]]).
 *Remarks:* Returns the first argument when the arguments are equivalent.
 ``` cpp
 template<class T>
+ constexpr T max(initializer_list<T> t);
 template<class T, class Compare>
+ constexpr T max(initializer_list<T> t, Compare comp);
 ```
 *Requires:* `T` is `LessThanComparable` and `CopyConstructible` and
 `t.size() > 0`.
 *Remarks:* Returns a copy of the leftmost argument when several
 arguments are equivalent to the largest.
 ``` cpp
+template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
 template<class T, class Compare>
+ constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
 ```
 *Requires:* Type `T` shall be `LessThanComparable`
 (Table  [[lessthancomparable]]).
 *Complexity:* Exactly one comparison.
 ``` cpp
 template<class T>
+ constexpr pair<T, T> minmax(initializer_list<T> t);
 template<class T, class Compare>
+ constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
 ```
 *Requires:* `T` is `LessThanComparable` and `CopyConstructible` and
 `t.size() > 0`.
   ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                             Compare comp);
 ```
 *Returns:* The first iterator `i` in the range \[`first`, `last`) such
+that for every iterator `j` in the range \[`first`, `last`) the
+following corresponding conditions hold: `!(*j < *i)` or
+`comp(*j, *i) == false`. Returns `last` if `first == last`.
 *Complexity:* Exactly `max((last - first) - 1, 0)` applications of the
 corresponding comparisons.
 ``` cpp
   ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                             Compare comp);
 ```
 *Returns:* The first iterator `i` in the range \[`first`, `last`) such
+that for every iterator `j` in the range \[`first`, `last`) the
+following corresponding conditions hold: `!(*i < *j)` or
+`comp(*i, *j) == false`. Returns `last` if `first == last`.
 *Complexity:* Exactly `max((last - first) - 1, 0)` applications of the
 corresponding comparisons.
 ``` cpp
 [alg.sort]: #alg.sort
 [alg.sorting]: #alg.sorting
 [alg.swap]: #alg.swap
 [alg.transform]: #alg.transform
 [alg.unique]: #alg.unique
+[algorithm.stable]: library.md#algorithm.stable
 [algorithms]: #algorithms
 [algorithms.general]: #algorithms.general
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [binary.search]: #binary.search
 [class.conv]: special.md#class.conv

Diff to HTML by rtfpessoa