[alg.nonmodifying] - C++11 → C++14

Files changed (1) hide show

tmp/tmpq_hi5jn7/{from.md → to.md} +69 -21

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

@@ -103,11 +103,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.
@@ -192,24 +192,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>
@@ -221,19 +236,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>
@@ -241,27 +273,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>
@@ -278,11 +326,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.
@@ -306,11 +354,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

 ```
 *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

Diff to HTML by rtfpessoa