From Jason Turner

[alg.rotate]

C++23 → Trunk 3.7 KB 63 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp71uuhy14/{from.md → to.md} +57 -0
tmp/tmp71uuhy14/{from.md → to.md} RENAMED
@@ -9,10 +9,13 @@ template<class ExecutionPolicy, class ForwardIterator>
9
  rotate(ExecutionPolicy&& exec,
10
  ForwardIterator first, ForwardIterator middle, ForwardIterator last);
11
 
12
  template<permutable I, sentinel_for<I> S>
13
  constexpr subrange<I> ranges::rotate(I first, I middle, S last);
 
 
 
14
  ```
15
 
16
  *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
17
  ranges. For the overloads in namespace `std`, `ForwardIterator` meets
18
  the *Cpp17ValueSwappable* requirements [[swappable.requirements]], and
@@ -41,10 +44,22 @@ template<forward_range R>
41
  ```
42
 
43
  *Effects:* Equivalent to:
44
  `return ranges::rotate(ranges::begin(r), middle, ranges::end(r));`
45
 
 
 
 
 
 
 
 
 
 
 
 
 
46
  ``` cpp
47
  template<class ForwardIterator, class OutputIterator>
48
  constexpr OutputIterator
49
  rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
50
  OutputIterator result);
@@ -76,10 +91,38 @@ following assignment takes place:
76
  - `result + `N for the overloads in namespace `std`.
77
  - `{last, result + `N`}` for the overload in namespace `ranges`.
78
 
79
  *Complexity:* Exactly N assignments.
80
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
81
  ``` cpp
82
  template<forward_range R, weakly_incrementable O>
83
  requires indirectly_copyable<iterator_t<R>, O>
84
  constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
85
  ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
@@ -89,5 +132,19 @@ template<forward_range R, weakly_incrementable O>
89
 
90
  ``` cpp
91
  return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), std::move(result));
92
  ```
93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9
  rotate(ExecutionPolicy&& exec,
10
  ForwardIterator first, ForwardIterator middle, ForwardIterator last);
11
 
12
  template<permutable I, sentinel_for<I> S>
13
  constexpr subrange<I> ranges::rotate(I first, I middle, S last);
14
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
15
+ requires permutable<I>
16
+ subrange<I> ranges::rotate(Ep&& exec, I first, I middle, S last);
17
  ```
18
 
19
  *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
20
  ranges. For the overloads in namespace `std`, `ForwardIterator` meets
21
  the *Cpp17ValueSwappable* requirements [[swappable.requirements]], and
 
44
  ```
45
 
46
  *Effects:* Equivalent to:
47
  `return ranges::rotate(ranges::begin(r), middle, ranges::end(r));`
48
 
49
+ ``` cpp
50
+ template<execution-policy Ep, sized-random-access-range R>
51
+ requires permutable<iterator_t<R>>
52
+ borrowed_subrange_t<R> ranges::rotate(Ep&& exec, R&& r, iterator_t<R> middle);
53
+ ```
54
+
55
+ *Effects:* Equivalent to:
56
+
57
+ ``` cpp
58
+ return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r));
59
+ ```
60
+
61
  ``` cpp
62
  template<class ForwardIterator, class OutputIterator>
63
  constexpr OutputIterator
64
  rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
65
  OutputIterator result);
 
91
  - `result + `N for the overloads in namespace `std`.
92
  - `{last, result + `N`}` for the overload in namespace `ranges`.
93
 
94
  *Complexity:* Exactly N assignments.
95
 
96
+ ``` cpp
97
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
98
+ random_access_iterator O, sized_sentinel_for<O> OutS>
99
+ requires indirectly_copyable<I, O>
100
+ ranges::rotate_copy_truncated_result<I, O>
101
+ ranges::rotate_copy(Ep&& exec, I first, I middle, S last, O result, OutS result_last);
102
+ ```
103
+
104
+ Let M be `last - first` and N be min(M, `result_last - result`).
105
+
106
+ *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
107
+ ranges. The ranges \[`first`, `last`) and \[`result`, `result + `N) do
108
+ not overlap.
109
+
110
+ *Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
111
+ `result + `N) such that for each non-negative integer i < N the
112
+ following assignment takes place:
113
+ `*(result + `i`) = *(first + (`i` + (middle - first)) % `M`)`.
114
+
115
+ *Returns:*
116
+
117
+ - `{middle + `N`, first, result + `N`}` if N is less than
118
+ `last - middle`.
119
+ - Otherwise,
120
+ `{last, first + (`N` + (middle - first)) % `M`, result + `N`}`.
121
+
122
+ *Complexity:* Exactly N assignments.
123
+
124
  ``` cpp
125
  template<forward_range R, weakly_incrementable O>
126
  requires indirectly_copyable<iterator_t<R>, O>
127
  constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
128
  ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
 
132
 
133
  ``` cpp
134
  return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), std::move(result));
135
  ```
136
 
137
+ ``` cpp
138
+ template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
139
+ requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
140
+ ranges::rotate_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
141
+ ranges::rotate_copy(Ep&& exec, R&& r, iterator_t<R> middle, OutR&& result_r);
142
+ ```
143
+
144
+ *Effects:* Equivalent to:
145
+
146
+ ``` cpp
147
+ return ranges::rotate_copy(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r),
148
+ ranges::begin(result_r), ranges::end(result_r));
149
+ ```
150
+