From Jason Turner

[alg.min.max]

C++23 → Trunk 6.3 KB 53 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/tmpl72oxqav/{from.md → to.md} +45 -0
tmp/tmpl72oxqav/{from.md → to.md} RENAMED
@@ -35,10 +35,15 @@ template<copyable T, class Proj = identity,
35
  template<input_range R, class Proj = identity,
36
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
37
  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
38
  constexpr range_value_t<R>
39
  ranges::min(R&& r, Comp comp = {}, Proj proj = {});
 
 
 
 
 
40
  ```
41
 
42
  *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
43
  namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
44
  For the first form, `T` meets the *Cpp17LessThanComparable* requirements
@@ -88,10 +93,15 @@ template<copyable T, class Proj = identity,
88
  template<input_range R, class Proj = identity,
89
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
90
  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
91
  constexpr range_value_t<R>
92
  ranges::max(R&& r, Comp comp = {}, Proj proj = {});
 
 
 
 
 
93
  ```
94
 
95
  *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
96
  namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
97
  For the first form, `T` meets the *Cpp17LessThanComparable* requirements
@@ -142,10 +152,15 @@ template<copyable T, class Proj = identity,
142
  template<input_range R, class Proj = identity,
143
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
144
  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
145
  constexpr ranges::minmax_result<range_value_t<R>>
146
  ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
 
 
 
 
 
147
  ```
148
 
149
  *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
150
  namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
151
  For the first form, type `T` meets the *Cpp17LessThanComparable*
@@ -182,10 +197,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
182
  constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
183
  template<forward_range R, class Proj = identity,
184
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
185
  constexpr borrowed_iterator_t<R>
186
  ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
 
 
 
 
 
 
 
 
 
 
187
  ```
188
 
189
  Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
190
  no parameters by those names.
191
 
@@ -221,10 +246,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
221
  constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
222
  template<forward_range R, class Proj = identity,
223
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
224
  constexpr borrowed_iterator_t<R>
225
  ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
 
 
 
 
 
 
 
 
 
 
226
  ```
227
 
228
  Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
229
  no parameters by those names.
230
 
@@ -263,10 +298,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
263
  ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
264
  template<forward_range R, class Proj = identity,
265
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
266
  constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
267
  ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
 
 
 
 
 
 
 
 
 
 
268
  ```
269
 
270
  *Returns:* `{first, first}` if \[`first`, `last`) is empty, otherwise
271
  `{m, M}`, where `m` is the first iterator in \[`first`, `last`) such
272
  that no iterator in the range refers to a smaller element, and where `M`
 
35
  template<input_range R, class Proj = identity,
36
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
37
  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
38
  constexpr range_value_t<R>
39
  ranges::min(R&& r, Comp comp = {}, Proj proj = {});
40
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
41
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
42
+ requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
43
+ range_value_t<R>
44
+ ranges::min(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
45
  ```
46
 
47
  *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
48
  namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
49
  For the first form, `T` meets the *Cpp17LessThanComparable* requirements
 
93
  template<input_range R, class Proj = identity,
94
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
95
  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
96
  constexpr range_value_t<R>
97
  ranges::max(R&& r, Comp comp = {}, Proj proj = {});
98
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
99
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
100
+ requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
101
+ range_value_t<R>
102
+ ranges::max(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
103
  ```
104
 
105
  *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
106
  namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
107
  For the first form, `T` meets the *Cpp17LessThanComparable* requirements
 
152
  template<input_range R, class Proj = identity,
153
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
154
  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
155
  constexpr ranges::minmax_result<range_value_t<R>>
156
  ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
157
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
158
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
159
+ requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
160
+ ranges::minmax_result<range_value_t<R>>
161
+ ranges::minmax(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
162
  ```
163
 
164
  *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
165
  namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
166
  For the first form, type `T` meets the *Cpp17LessThanComparable*
 
197
  constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
198
  template<forward_range R, class Proj = identity,
199
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
200
  constexpr borrowed_iterator_t<R>
201
  ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
202
+
203
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
204
+ class Proj = identity,
205
+ indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
206
+ I ranges::min_element(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
207
+ template<execution-policy Ep, sized-random-access-range R,
208
+ class Proj = identity,
209
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
210
+ borrowed_iterator_t<R>
211
+ ranges::min_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
212
  ```
213
 
214
  Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
215
  no parameters by those names.
216
 
 
246
  constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
247
  template<forward_range R, class Proj = identity,
248
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
249
  constexpr borrowed_iterator_t<R>
250
  ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
251
+
252
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
253
+ class Proj = identity,
254
+ indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
255
+ I ranges::max_element(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
256
+ template<execution-policy Ep, sized-random-access-range R,
257
+ class Proj = identity,
258
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
259
+ borrowed_iterator_t<R>
260
+ ranges::max_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
261
  ```
262
 
263
  Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
264
  no parameters by those names.
265
 
 
298
  ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
299
  template<forward_range R, class Proj = identity,
300
  indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
301
  constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
302
  ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
303
+
304
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
305
+ class Proj = identity,
306
+ indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
307
+ ranges::minmax_element_result<I>
308
+ ranges::minmax_element(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
309
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
310
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
311
+ ranges::minmax_element_result<borrowed_iterator_t<R>>
312
+ ranges::minmax_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
313
  ```
314
 
315
  *Returns:* `{first, first}` if \[`first`, `last`) is empty, otherwise
316
  `{m, M}`, where `m` is the first iterator in \[`first`, `last`) such
317
  that no iterator in the range refers to a smaller element, and where `M`