[alg.modifying.operations] - C++11 → C++14

Files changed (1) hide show

tmp/tmp9jj9b0gq/{from.md → to.md} +26 -49

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

@@ -42,14 +42,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,
@@ -297,19 +299,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,
@@ -321,22 +323,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>
@@ -398,13 +400,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.
@@ -414,13 +415,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)`.
@@ -443,12 +444,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.
@@ -469,22 +470,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);
 ```
@@ -492,35 +484,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>
@@ -544,12 +521,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]]).
@@ -566,12 +543,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`
@@ -590,13 +567,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.

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

Diff to HTML by rtfpessoa