Google Git
Sign in
chromium / external / github.com / llvm / llvm-project.git / 72f57e3a30d597346feec74cf626796b0055680f / . / libcxx / include / algorithm
blob: 7b510b5096afdc2488b1acda2d79ff87d648902b [file] [log] [blame]
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1// -*- C++ -*-
Louis Dionneeb8650a2021-11-17 21:25:01[diff] [blame]2//===----------------------------------------------------------------------===//
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]3//
Chandler Carruth57b08b02019-01-19 10:56:40[diff] [blame]4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_ALGORITHM
11#define _LIBCPP_ALGORITHM
12
13/*
14 algorithm synopsis
15
16#include <initializer_list>
17
18namespace std
19{
20
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]21namespace ranges {
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]22
23 // [algorithms.results], algorithm result types
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]24 template <class I, class F>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]25 struct in_fun_result; // since C++20
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]26
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]27 template <class I1, class I2>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]28 struct in_in_result; // since C++20
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame]29
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]30 template <class I, class O>
31 struct in_out_result; // since C++20
32
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame]33 template <class I1, class I2, class O>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]34 struct in_in_out_result; // since C++20
Nikolas Klauser610979b2022-02-03 01:17:03[diff] [blame]35
36 template <class I, class O1, class O2>
37 struct in_out_out_result; // since C++20
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]38
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]39 template <class I1, class I2>
40 struct min_max_result; // since C++20
41
Nikolas Klauser68f41312022-02-21 22:07:02[diff] [blame]42 template <class I>
43 struct in_found_result; // since C++20
44
Nikolas Klauser3b470d12022-02-11 12:11:57[diff] [blame]45 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
46 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> // since C++20
47 constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
48
49 template<forward_range R, class Proj = identity,
50 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20
51 constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {});
Nikolas Klauserc2cd15a2022-03-08 22:12:35[diff] [blame]52
Nikolas Klauser40f7fca32022-05-22 11:43:37[diff] [blame]53 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
54 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
55 constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
56
57 template<forward_range R, class Proj = identity,
58 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
59 constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
60
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]61 template<class I1, class I2>
62 using mismatch_result = in_in_result<I1, I2>;
63
Nikolas Klauserc2cd15a2022-03-08 22:12:35[diff] [blame]64 template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2,
65 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
66 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
67 constexpr mismatch_result<_I1, _I2>
68 mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
69
70 template <input_range R1, input_range R2,
71 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
72 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
73 constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
74 mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]75
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]76 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
77 constexpr I find(I first, S last, const T& value, Proj proj = {}); // since C++20
78
79 template<input_range R, class T, class Proj = identity>
80 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
81 constexpr borrowed_iterator_t<R>
82 find(R&& r, const T& value, Proj proj = {}); // since C++20
83
84 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
85 indirect_unary_predicate<projected<I, Proj>> Pred>
86 constexpr I find_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
87
88 template<input_range R, class Proj = identity,
89 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
90 constexpr borrowed_iterator_t<R>
91 find_if(R&& r, Pred pred, Proj proj = {}); // since C++20
92
93 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
94 indirect_unary_predicate<projected<I, Proj>> Pred>
95 constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {}); // since C++20
96
97 template<input_range R, class Proj = identity,
98 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
99 constexpr borrowed_iterator_t<R>
100 find_if_not(R&& r, Pred pred, Proj proj = {}); // since C++20
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]101
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]102 template<class T, class Proj = identity,
103 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
104 constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]105
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]106 template<copyable T, class Proj = identity,
107 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
108 constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]109
110 template<input_range R, class Proj = identity,
111 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
112 requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
113 constexpr range_value_t<R>
114 min(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]115
116 template<class T, class Proj = identity,
117 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
118 constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
119
120 template<copyable T, class Proj = identity,
121 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
122 constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20
123
124 template<input_range R, class Proj = identity,
125 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
126 requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
127 constexpr range_value_t<R>
128 max(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauser3ba85482022-04-05 09:05:36[diff] [blame]129
130 template<class I, class O>
131 using unary_transform_result = in_out_result<I, O>; // since C++20
132
133 template<class I1, class I2, class O>
134 using binary_transform_result = in_in_out_result<I1, I2, O>; // since C++20
135
136 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
137 copy_constructible F, class Proj = identity>
138 requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
139 constexpr ranges::unary_transform_result<I, O>
140 transform(I first1, S last1, O result, F op, Proj proj = {}); // since C++20
141
142 template<input_range R, weakly_incrementable O, copy_constructible F,
143 class Proj = identity>
144 requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
145 constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
146 transform(R&& r, O result, F op, Proj proj = {}); // since C++20
147
148 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
149 weakly_incrementable O, copy_constructible F, class Proj1 = identity,
150 class Proj2 = identity>
151 requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
152 projected<I2, Proj2>>>
153 constexpr ranges::binary_transform_result<I1, I2, O>
154 transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
155 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
156
157 template<input_range R1, input_range R2, weakly_incrementable O,
158 copy_constructible F, class Proj1 = identity, class Proj2 = identity>
159 requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
160 projected<iterator_t<R2>, Proj2>>>
161 constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
162 transform(R1&& r1, R2&& r2, O result,
163 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauser1306b102022-04-07 11:02:02[diff] [blame]164
165 template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
166 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
167 constexpr iter_difference_t<I>
168 count(I first, S last, const T& value, Proj proj = {}); // since C++20
169
170 template<input_range R, class T, class Proj = identity>
171 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
172 constexpr range_difference_t<R>
173 count(R&& r, const T& value, Proj proj = {}); // since C++20
174
175 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
176 indirect_unary_predicate<projected<I, Proj>> Pred>
177 constexpr iter_difference_t<I>
178 count_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
179
180 template<input_range R, class Proj = identity,
181 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
182 constexpr range_difference_t<R>
183 count_if(R&& r, Pred pred, Proj proj = {}); // since C++20
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]184
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]185 template<class T>
186 using minmax_result = min_max_result<T>;
187
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]188 template<class T, class Proj = identity,
189 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
190 constexpr ranges::minmax_result<const T&>
191 minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
192
193 template<copyable T, class Proj = identity,
194 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
195 constexpr ranges::minmax_result<T>
196 minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20
197
198 template<input_range R, class Proj = identity,
199 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
200 requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
201 constexpr ranges::minmax_result<range_value_t<R>>
202 minmax(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
203
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]204 template<class I>
205 using minmax_element_result = min_max_result<I>;
206
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]207 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
208 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
209 constexpr ranges::minmax_element_result<I>
210 minmax_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
211
212 template<forward_range R, class Proj = identity,
213 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
214 constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
215 minmax_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]216
217 template<class I, class O>
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]218 using copy_result = in_out_result<I, O>; // since C++20
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]219
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]220 template<class I, class O>
221 using copy_n_result = in_out_result<I, O>; // since C++20
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]222
223 template<class I, class O>
224 using copy_if_result = in_out_result<I, O>; // since C++20
225
226 template<class I1, class I2>
227 using copy_backward_result = in_out_result<I1, I2>; // since C++20
228
229 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
230 requires indirectly_copyable<I, O>
231 constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result); // since C++20
232
233 template<input_range R, weakly_incrementable O>
234 requires indirectly_copyable<iterator_t<R>, O>
235 constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result); // since C++20
236
237 template<input_iterator I, weakly_incrementable O>
238 requires indirectly_copyable<I, O>
239 constexpr ranges::copy_n_result<I, O>
240 ranges::copy_n(I first, iter_difference_t<I> n, O result); // since C++20
241
242 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
243 indirect_unary_predicate<projected<I, Proj>> Pred>
244 requires indirectly_copyable<I, O>
245 constexpr ranges::copy_if_result<I, O>
246 ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {}); // since C++20
247
248 template<input_range R, weakly_incrementable O, class Proj = identity,
249 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
250 requires indirectly_copyable<iterator_t<R>, O>
251 constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
252 ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {}); // since C++20
253
254 template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
255 requires indirectly_copyable<I1, I2>
256 constexpr ranges::copy_backward_result<I1, I2>
257 ranges::copy_backward(I1 first, S1 last, I2 result); // since C++20
258
259 template<bidirectional_range R, bidirectional_iterator I>
260 requires indirectly_copyable<iterator_t<R>, I>
261 constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
262 ranges::copy_backward(R&& r, I result); // since C++20
Nikolas Klauser80045e92022-05-04 18:27:07[diff] [blame]263
264 template<class I, class F>
265 using for_each_result = in_fun_result<I, F>; // since C++20
266
267 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
268 indirectly_unary_invocable<projected<I, Proj>> Fun>
269 constexpr ranges::for_each_result<I, Fun>
270 ranges::for_each(I first, S last, Fun f, Proj proj = {}); // since C++20
271
272 template<input_range R, class Proj = identity,
273 indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
274 constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun>
275 ranges::for_each(R&& r, Fun f, Proj proj = {}); // since C++20
276
277 template<input_iterator I, class Proj = identity,
278 indirectly_unary_invocable<projected<I, Proj>> Fun>
279 constexpr ranges::for_each_n_result<I, Fun>
280 ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {}); // since C++20
Nikolas Klauser37ba1b92022-05-04 12:19:09[diff] [blame]281
282 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
283 indirect_unary_predicate<projected<I, Proj>> Pred>
284 constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {}); // since C++20
285
286 template<input_range R, class Proj = identity,
287 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
288 constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {}); // since C++20
289
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]290 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
291 class Proj = identity>
292 requires sortable<I, Comp, Proj>
293 constexpr I
294 ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
295
296 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
297 requires sortable<iterator_t<R>, Comp, Proj>
298 constexpr borrowed_iterator_t<R>
299 ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
300
301 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
302 class Proj = identity>
303 requires sortable<I, Comp, Proj>
304 constexpr I
305 ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
306
307 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
308 requires sortable<iterator_t<R>, Comp, Proj>
309 constexpr borrowed_iterator_t<R>
310 ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
311
312 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
313 class Proj = identity>
314 requires sortable<I, Comp, Proj>
315 constexpr I
316 ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
317
318 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
319 requires sortable<iterator_t<R>, Comp, Proj>
320 constexpr borrowed_iterator_t<R>
321 ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
322
323 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
324 class Proj = identity>
325 requires sortable<I, Comp, Proj>
326 constexpr I
327 ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
328
329 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
330 requires sortable<iterator_t<R>, Comp, Proj>
331 constexpr borrowed_iterator_t<R>
332 ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
333
Konstantin Varlamovd406c642022-07-26 23:11:09[diff] [blame]334 template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
335 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
336 constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {}); // Since C++20
337
338 template<random_access_range R, class Proj = identity,
339 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
340 constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {}); // Since C++20
341
342 template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
343 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
344 constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {}); // Since C++20
345
346 template<random_access_range R, class Proj = identity,
347 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
348 constexpr borrowed_iterator_t<R>
349 is_heap_until(R&& r, Comp comp = {}, Proj proj = {}); // Since C++20
350
Nikolas Klauser1d1a1912022-05-24 08:32:50[diff] [blame]351 template<bidirectional_iterator I, sentinel_for<I> S>
352 requires permutable<I>
353 constexpr I ranges::reverse(I first, S last); // since C++20
354
355 template<bidirectional_range R>
356 requires permutable<iterator_t<R>>
357 constexpr borrowed_iterator_t<R> ranges::reverse(R&& r); // since C++20
358
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]359 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
360 class Proj = identity>
361 requires sortable<I, Comp, Proj>
362 constexpr I
Konstantin Varlamov94c7b892022-07-01 23:34:08[diff] [blame]363 ranges::sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]364
365 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
366 requires sortable<iterator_t<R>, Comp, Proj>
367 constexpr borrowed_iterator_t<R>
Konstantin Varlamov94c7b892022-07-01 23:34:08[diff] [blame]368 ranges::sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
369
370 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
371 class Proj = identity>
372 requires sortable<I, Comp, Proj>
373 I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
374
375 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
376 requires sortable<iterator_t<R>, Comp, Proj>
377 borrowed_iterator_t<R>
378 ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]379
varconst5dd19ad2022-07-20 03:10:02[diff] [blame]380 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
381 class Proj = identity>
382 requires sortable<I, Comp, Proj>
383 constexpr I
384 ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {}); // since C++20
385
386 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
387 requires sortable<iterator_t<R>, Comp, Proj>
388 constexpr borrowed_iterator_t<R>
389 ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {}); // since C++20
390
Nikolas Klauser7af89a32022-05-21 16:26:29[diff] [blame]391 template<class T, output_iterator<const T&> O, sentinel_for<O> S>
392 constexpr O ranges::fill(O first, S last, const T& value); // since C++20
393
394 template<class T, output_range<const T&> R>
395 constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value); // since C++20
396
397 template<class T, output_iterator<const T&> O>
398 constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value); // since C++20
Nikolas Klauser569d6632022-05-25 09:09:43[diff] [blame]399
Konstantin Varlamovead73022022-07-26 22:50:14[diff] [blame]400 template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
401 requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
402 constexpr O generate(O first, S last, F gen); // Since C++20
403
404 template<class R, copy_constructible F>
405 requires invocable<F&> && output_range<R, invoke_result_t<F&>>
406 constexpr borrowed_iterator_t<R> generate(R&& r, F gen); // Since C++20
407
408 template<input_or_output_iterator O, copy_constructible F>
409 requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
410 constexpr O generate_n(O first, iter_difference_t<O> n, F gen); // Since C++20
411
Nikolas Klauser569d6632022-05-25 09:09:43[diff] [blame]412 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
413 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
414 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
415 constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
416 Pred pred = {},
417 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
418
419 template<input_range R1, input_range R2, class Pred = ranges::equal_to,
420 class Proj1 = identity, class Proj2 = identity>
421 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
422 constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
423 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
424
Nikolas Klauser0e3dc1a2022-05-26 14:42:46[diff] [blame]425 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
426 indirect_unary_predicate<projected<I, Proj>> Pred>
427 constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
428
429 template<input_range R, class Proj = identity,
430 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
431 constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {}); // since C++20
432
433 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
434 indirect_unary_predicate<projected<I, Proj>> Pred>
435 constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
436
437 template<input_range R, class Proj = identity,
438 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
439 constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {}); // since C++20
440
441 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
442 indirect_unary_predicate<projected<I, Proj>> Pred>
443 constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
444
445 template<input_range R, class Proj = identity,
446 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
447 constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {}); // since C++20
448
Nikolas Klauser11e3ad22022-05-26 14:08:55[diff] [blame]449 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
450 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
451 constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
452
453 template<forward_range R, class Proj = identity,
454 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
455 constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
456
457 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
458 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
459 constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
460
461 template<forward_range R, class Proj = identity,
462 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
463 constexpr borrowed_iterator_t<R>
464 ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]465
Konstantin Varlamov23c73282022-07-08 03:35:51[diff] [blame]466 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
467 class Proj = identity>
468 requires sortable<I, Comp, Proj>
469 constexpr I
470 ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {}); // since C++20
471
472 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
473 requires sortable<iterator_t<R>, Comp, Proj>
474 constexpr borrowed_iterator_t<R>
475 ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {}); // since C++20
476
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]477 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
478 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
479 constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
480
481 template<forward_range R, class T, class Proj = identity,
482 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
483 ranges::less>
484 constexpr borrowed_iterator_t<R>
485 upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
486
487 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
488 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
489 constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
490 Proj proj = {}); // since C++20
491 template<forward_range R, class T, class Proj = identity,
492 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
493 ranges::less>
494 constexpr borrowed_iterator_t<R>
495 lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
496
497 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
498 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
499 constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
500 Proj proj = {}); // since C++20
Nikolas Klauserb79b2b62022-06-06 11:57:34[diff] [blame]501
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]502 template<forward_range R, class T, class Proj = identity,
503 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
504 ranges::less>
505 constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
506 Proj proj = {}); // since C++20
Konstantin Varlamov8ed702b2022-07-19 04:05:51[diff] [blame]507
508 template<permutable I, sentinel_for<I> S, class Proj = identity,
509 indirect_unary_predicate<projected<I, Proj>> Pred>
510 constexpr subrange<I>
511 partition(I first, S last, Pred pred, Proj proj = {}); // Since C++20
512
513 template<forward_range R, class Proj = identity,
514 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
515 requires permutable<iterator_t<R>>
516 constexpr borrowed_subrange_t<R>
517 partition(R&& r, Pred pred, Proj proj = {}); // Since C++20
518
519 template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
520 indirect_unary_predicate<projected<I, Proj>> Pred>
521 requires permutable<I>
522 subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {}); // Since C++20
523
524 template<bidirectional_range R, class Proj = identity,
525 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
526 requires permutable<iterator_t<R>>
527 borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {}); // Since C++20
528
Nikolas Klauserb79b2b62022-06-06 11:57:34[diff] [blame]529 template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
530 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
531 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
532 constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
533 Pred pred = {},
534 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
535
536 template<input_range R1, forward_range R2,
537 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
538 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
539 constexpr borrowed_iterator_t<R1>
540 ranges::find_first_of(R1&& r1, R2&& r2,
541 Pred pred = {},
542 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]543
Nikolas Klauser916e9052022-06-08 10:14:12[diff] [blame]544 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
545 indirect_binary_predicate<projected<I, Proj>,
546 projected<I, Proj>> Pred = ranges::equal_to>
547 constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {}); // since C+20
548
549 template<forward_range R, class Proj = identity,
550 indirect_binary_predicate<projected<iterator_t<R>, Proj>,
551 projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
552 constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // since C++20
553
Nikolas Klauserff6d5de2022-06-07 07:42:10[diff] [blame]554 template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
555 requires indirectly_writable<I, const T2&> &&
556 indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
557 constexpr I
558 ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20
559
560 template<input_range R, class T1, class T2, class Proj = identity>
561 requires indirectly_writable<iterator_t<R>, const T2&> &&
562 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
563 constexpr borrowed_iterator_t<R>
564 ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20
565
566 template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
567 indirect_unary_predicate<projected<I, Proj>> Pred>
568 requires indirectly_writable<I, const T&>
569 constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20
570
571 template<input_range R, class T, class Proj = identity,
572 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
573 requires indirectly_writable<iterator_t<R>, const T&>
574 constexpr borrowed_iterator_t<R>
575 ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {}); // since C++20
576
Nikolas Klauserafd5a4f2022-06-15 14:24:43[diff] [blame]577 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
578 class Proj1 = identity, class Proj2 = identity,
579 indirect_strict_weak_order<projected<I1, Proj1>,
580 projected<I2, Proj2>> Comp = ranges::less>
581 constexpr bool
582 ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
583 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
584
585 template<input_range R1, input_range R2, class Proj1 = identity,
586 class Proj2 = identity,
587 indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
588 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
589 constexpr bool
590 ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
591 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
592
Nikolas Klauser2c3bbac2022-06-23 10:23:41[diff] [blame]593 template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
594 requires indirectly_movable<I1, I2>
595 constexpr ranges::move_backward_result<I1, I2>
596 ranges::move_backward(I1 first, S1 last, I2 result); // since C++20
597
598 template<bidirectional_range R, bidirectional_iterator I>
599 requires indirectly_movable<iterator_t<R>, I>
600 constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
601 ranges::move_backward(R&& r, I result); // since C++20
602
603 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
604 requires indirectly_movable<I, O>
605 constexpr ranges::move_result<I, O>
606 ranges::move(I first, S last, O result); // since C++20
607
608 template<input_range R, weakly_incrementable O>
609 requires indirectly_movable<iterator_t<R>, O>
610 constexpr ranges::move_result<borrowed_iterator_t<R>, O>
611 ranges::move(R&& r, O result); // since C++20
612
Konstantin Varlamov065202f2022-07-20 08:57:13[diff] [blame]613 template<class I, class O1, class O2>
614 using partition_copy_result = in_out_out_result<I, O1, O2>; // since C++20
615
616 template<input_iterator I, sentinel_for<I> S,
617 weakly_incrementable O1, weakly_incrementable O2,
618 class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
619 requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
620 constexpr partition_copy_result<I, O1, O2>
621 partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
622 Proj proj = {}); // Since C++20
623
624 template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
625 class Proj = identity,
626 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
627 requires indirectly_copyable<iterator_t<R>, O1> &&
628 indirectly_copyable<iterator_t<R>, O2>
629 constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2>
630 partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {}); // Since C++20
631
632 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
633 indirect_unary_predicate<projected<I, Proj>> Pred>
634 constexpr I partition_point(I first, S last, Pred pred, Proj proj = {}); // Since C++20
635
636 template<forward_range R, class Proj = identity,
637 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
638 constexpr borrowed_iterator_t<R>
639 partition_point(R&& r, Pred pred, Proj proj = {}); // Since C++20
640
Hui Xie25607d12022-06-26 15:13:43[diff] [blame]641 template<class I1, class I2, class O>
642 using merge_result = in_in_out_result<I1, I2, O>; // since C++20
643
644 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
645 weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
646 class Proj2 = identity>
647 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
648 constexpr merge_result<I1, I2, O>
649 merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
650 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
651
652 template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
653 class Proj1 = identity, class Proj2 = identity>
654 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
655 constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
656 merge(R1&& r1, R2&& r2, O result,
657 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauser2c3bbac2022-06-23 10:23:41[diff] [blame]658
Nikolas Klauserf8cbe3cdf2022-07-06 12:03:00[diff] [blame]659 template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
660 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
661 constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {}); // since C++20
662
663 template<forward_range R, class T, class Proj = identity>
664 requires permutable<iterator_t<R>> &&
665 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
666 constexpr borrowed_subrange_t<R>
667 ranges::remove(R&& r, const T& value, Proj proj = {}); // since C++20
668
669 template<permutable I, sentinel_for<I> S, class Proj = identity,
670 indirect_unary_predicate<projected<I, Proj>> Pred>
671 constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
672
673 template<forward_range R, class Proj = identity,
674 indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
675 requires permutable<iterator_t<R>>
676 constexpr borrowed_subrange_t<R>
677 ranges::remove_if(R&& r, Pred pred, Proj proj = {}); // since C++20
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]678
Hui Xie1cdec6c2022-06-26 15:13:43[diff] [blame]679 template<class I, class O>
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]680 using set_difference_result = in_out_result<I, O>; // since C++20
Hui Xie1cdec6c2022-06-26 15:13:43[diff] [blame]681
682 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
683 weakly_incrementable O, class Comp = ranges::less,
684 class Proj1 = identity, class Proj2 = identity>
685 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
686 constexpr set_difference_result<I1, O>
687 set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
688 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
689
690 template<input_range R1, input_range R2, weakly_incrementable O,
691 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
692 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
693 constexpr set_difference_result<borrowed_iterator_t<R1>, O>
694 set_difference(R1&& r1, R2&& r2, O result,
695 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Nikolas Klauserf8cbe3cdf2022-07-06 12:03:00[diff] [blame]696
Hui Xie96b674f2022-07-08 14:21:40[diff] [blame]697 template<class I1, class I2, class O>
698 using set_intersection_result = in_in_out_result<I1, I2, O>; // since C++20
699
700 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
701 weakly_incrementable O, class Comp = ranges::less,
702 class Proj1 = identity, class Proj2 = identity>
703 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
704 constexpr set_intersection_result<I1, I2, O>
705 set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
706 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
707
708 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
709 weakly_incrementable O, class Comp = ranges::less,
710 class Proj1 = identity, class Proj2 = identity>
711 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
712 constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
713 set_intersection(R1&& r1, R2&& r2, O result,
714 Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
715
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]716 template <class _InIter, class _OutIter>
717 using reverse_copy_result = in_out_result<_InIter, _OutIter>; // since C++20
718
719 template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
720 requires indirectly_copyable<I, O>
721 constexpr ranges::reverse_copy_result<I, O>
722 ranges::reverse_copy(I first, S last, O result); // since C++20
723
724 template<bidirectional_range R, weakly_incrementable O>
725 requires indirectly_copyable<iterator_t<R>, O>
726 constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O>
727 ranges::reverse_copy(R&& r, O result); // since C++20
728
729 template <class _InIter, class _OutIter>
730 using rotate_copy_result = in_out_result<_InIter, _OutIter>; // since C++20
731
732 template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
733 requires indirectly_copyable<I, O>
734 constexpr ranges::rotate_copy_result<I, O>
735 ranges::rotate_copy(I first, I middle, S last, O result); // since C++20
736
737 template<forward_range R, weakly_incrementable O>
738 requires indirectly_copyable<iterator_t<R>, O>
739 constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
740 ranges::rotate_copy(R&& r, iterator_t<R> middle, O result); // since C++20
741
Konstantin Varlamov14cf74d2022-07-22 16:58:56[diff] [blame]742 template<random_access_iterator I, sentinel_for<I> S, class Gen>
743 requires permutable<I> &&
744 uniform_random_bit_generator<remove_reference_t<Gen>>
745 I shuffle(I first, S last, Gen&& g); // Since C++20
746
747 template<random_access_range R, class Gen>
748 requires permutable<iterator_t<R>> &&
749 uniform_random_bit_generator<remove_reference_t<Gen>>
750 borrowed_iterator_t<R> shuffle(R&& r, Gen&& g); // Since C++20
751
Nikolas Klauser101d1e92022-07-13 16:07:26[diff] [blame]752 template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
753 sentinel_for<I2> S2, class Pred = ranges::equal_to,
754 class Proj1 = identity, class Proj2 = identity>
755 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
756 constexpr subrange<I1>
757 ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
758 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
759
760 template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
761 class Proj1 = identity, class Proj2 = identity>
762 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
763 constexpr borrowed_subrange_t<R1>
764 ranges::search(R1&& r1, R2&& r2, Pred pred = {},
765 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
766
767 template<forward_iterator I, sentinel_for<I> S, class T,
768 class Pred = ranges::equal_to, class Proj = identity>
769 requires indirectly_comparable<I, const T*, Pred, Proj>
770 constexpr subrange<I>
771 ranges::search_n(I first, S last, iter_difference_t<I> count,
772 const T& value, Pred pred = {}, Proj proj = {}); // since C++20
773
774 template<forward_range R, class T, class Pred = ranges::equal_to,
775 class Proj = identity>
776 requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
777 constexpr borrowed_subrange_t<R>
778 ranges::search_n(R&& r, range_difference_t<R> count,
779 const T& value, Pred pred = {}, Proj proj = {}); // since C++20
780
781 template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
782 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
783 requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
784 constexpr subrange<I1>
785 ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
786 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
787
788 template<forward_range R1, forward_range R2,
789 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
790 requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
791 constexpr borrowed_subrange_t<R1>
792 ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
793 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
794
Hui Xiea5c06382022-07-11 22:39:59[diff] [blame]795 template<class I1, class I2, class O>
796 using set_symmetric_difference_result = in_in_out_result<I1, I2, O>; // since C++20
797
798 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
799 weakly_incrementable O, class Comp = ranges::less,
800 class Proj1 = identity, class Proj2 = identity>
801 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
802 constexpr set_symmetric_difference_result<I1, I2, O>
803 set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
804 Comp comp = {}, Proj1 proj1 = {},
805 Proj2 proj2 = {}); // since C++20
Hui Xie8a617492022-07-27 12:20:16[diff] [blame]806
Hui Xiea5c06382022-07-11 22:39:59[diff] [blame]807 template<input_range R1, input_range R2, weakly_incrementable O,
808 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
809 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
810 constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>,
811 borrowed_iterator_t<R2>, O>
812 set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
813 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Hui Xie0f6364b82022-07-14 19:35:15[diff] [blame]814
815 template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
816 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
817 constexpr subrange<I>
818 equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
Hui Xie8a617492022-07-27 12:20:16[diff] [blame]819
Hui Xie0f6364b82022-07-14 19:35:15[diff] [blame]820 template<forward_range R, class T, class Proj = identity,
821 indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
822 ranges::less>
823 constexpr borrowed_subrange_t<R>
824 equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
Hui Xie8a617492022-07-27 12:20:16[diff] [blame]825
Hui Xie3151b952022-07-13 16:20:22[diff] [blame]826 template<class I1, class I2, class O>
827 using set_union_result = in_in_out_result<I1, I2, O>; // since C++20
828
829 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
830 weakly_incrementable O, class Comp = ranges::less,
831 class Proj1 = identity, class Proj2 = identity>
832 requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
833 constexpr set_union_result<I1, I2, O>
834 set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
835 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
836
837 template<input_range R1, input_range R2, weakly_incrementable O,
838 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
839 requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
840 constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
841 set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
842 Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
Hui Xiec5599642022-07-19 19:54:35[diff] [blame]843
844 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
845 class Proj1 = identity, class Proj2 = identity,
846 indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
847 ranges::less>
848 constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
849 Proj1 proj1 = {}, Proj2 proj2 = {}); // Since C++20
Hui Xie8a617492022-07-27 12:20:16[diff] [blame]850
Hui Xiec5599642022-07-19 19:54:35[diff] [blame]851 template<input_range R1, input_range R2, class Proj1 = identity,
852 class Proj2 = identity,
853 indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
854 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
855 constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
856 Proj1 proj1 = {}, Proj2 proj2 = {}); // Since C++20
Hui Xie8a617492022-07-27 12:20:16[diff] [blame]857
858 template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
859 class Proj = identity>
860 requires sortable<I, Comp, Proj>
861 I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {}); // Since C++20
862
863 template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
864 requires sortable<iterator_t<R>, Comp, Proj>
865 borrowed_iterator_t<R>
866 inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
867 Proj proj = {}); // Since C++20
Hui Xie72f57e32022-07-23 00:44:25[diff] [blame^]868
869 template<permutable I, sentinel_for<I> S, class Proj = identity,
870 indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
871 constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {}); // Since C++20
872
873 template<forward_range R, class Proj = identity,
874 indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
875 requires permutable<iterator_t<R>>
876 constexpr borrowed_subrange_t<R>
877 unique(R&& r, C comp = {}, Proj proj = {}); // Since C++20
878
879 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
880 indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
881 requires indirectly_copyable<I, O> &&
882 (forward_iterator<I> ||
883 (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
884 indirectly_copyable_storable<I, O>)
885 constexpr unique_copy_result<I, O>
886 unique_copy(I first, S last, O result, C comp = {}, Proj proj = {}); // Since C++20
887
888 template<input_range R, weakly_incrementable O, class Proj = identity,
889 indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
890 requires indirectly_copyable<iterator_t<R>, O> &&
891 (forward_iterator<iterator_t<R>> ||
892 (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
893 indirectly_copyable_storable<iterator_t<R>, O>)
894 constexpr unique_copy_result<borrowed_iterator_t<R>, O>
895 unique_copy(R&& r, O result, C comp = {}, Proj proj = {}); // Since C++20
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]896}
897
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]898 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]899 all_of(InputIterator first, InputIterator last, Predicate pred);
900
901template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]902 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]903 any_of(InputIterator first, InputIterator last, Predicate pred);
904
905template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]906 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]907 none_of(InputIterator first, InputIterator last, Predicate pred);
908
909template <class InputIterator, class Function>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]910 constexpr Function // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]911 for_each(InputIterator first, InputIterator last, Function f);
912
Marshall Clowd5c65ff2017-05-25 02:29:54[diff] [blame]913template<class InputIterator, class Size, class Function>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]914 constexpr InputIterator // constexpr in C++20
915 for_each_n(InputIterator first, Size n, Function f); // C++17
Marshall Clowd5c65ff2017-05-25 02:29:54[diff] [blame]916
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]917template <class InputIterator, class T>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]918 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]919 find(InputIterator first, InputIterator last, const T& value);
920
921template <class InputIterator, class Predicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]922 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]923 find_if(InputIterator first, InputIterator last, Predicate pred);
924
925template<class InputIterator, class Predicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]926 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]927 find_if_not(InputIterator first, InputIterator last, Predicate pred);
928
929template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]930 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]931 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
932 ForwardIterator2 first2, ForwardIterator2 last2);
933
934template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]935 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]936 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
937 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
938
939template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]940 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]941 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
942 ForwardIterator2 first2, ForwardIterator2 last2);
943
944template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]945 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]946 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
947 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
948
949template <class ForwardIterator>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]950 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]951 adjacent_find(ForwardIterator first, ForwardIterator last);
952
953template <class ForwardIterator, class BinaryPredicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]954 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]955 adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
956
957template <class InputIterator, class T>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]958 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]959 count(InputIterator first, InputIterator last, const T& value);
960
961template <class InputIterator, class Predicate>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]962 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]963 count_if(InputIterator first, InputIterator last, Predicate pred);
964
965template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]966 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]967 mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
968
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]969template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]970 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Aditya Kumar331fb802016-08-25 11:52:38[diff] [blame]971 mismatch(InputIterator1 first1, InputIterator1 last1,
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]972 InputIterator2 first2, InputIterator2 last2); // **C++14**
973
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]974template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]975 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]976 mismatch(InputIterator1 first1, InputIterator1 last1,
977 InputIterator2 first2, BinaryPredicate pred);
978
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]979template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]980 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]981 mismatch(InputIterator1 first1, InputIterator1 last1,
982 InputIterator2 first2, InputIterator2 last2,
983 BinaryPredicate pred); // **C++14**
984
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]985template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]986 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]987 equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
988
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]989template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]990 constexpr bool // constexpr in C++20
Aditya Kumar331fb802016-08-25 11:52:38[diff] [blame]991 equal(InputIterator1 first1, InputIterator1 last1,
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]992 InputIterator2 first2, InputIterator2 last2); // **C++14**
993
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]994template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]995 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]996 equal(InputIterator1 first1, InputIterator1 last1,
997 InputIterator2 first2, BinaryPredicate pred);
998
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]999template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]1000 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]1001 equal(InputIterator1 first1, InputIterator1 last1,
1002 InputIterator2 first2, InputIterator2 last2,
1003 BinaryPredicate pred); // **C++14**
1004
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1005template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1006 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1007 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1008 ForwardIterator2 first2);
1009
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]1010template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1011 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]1012 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1013 ForwardIterator2 first2, ForwardIterator2 last2); // **C++14**
1014
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1015template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1016 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1017 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1018 ForwardIterator2 first2, BinaryPredicate pred);
1019
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]1020template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1021 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]1022 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1023 ForwardIterator2 first2, ForwardIterator2 last2,
1024 BinaryPredicate pred); // **C++14**
1025
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1026template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]1027 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1028 search(ForwardIterator1 first1, ForwardIterator1 last1,
1029 ForwardIterator2 first2, ForwardIterator2 last2);
1030
1031template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]1032 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1033 search(ForwardIterator1 first1, ForwardIterator1 last1,
1034 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
1035
1036template <class ForwardIterator, class Size, class T>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]1037 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1038 search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
1039
1040template <class ForwardIterator, class Size, class T, class BinaryPredicate>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]1041 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1042 search_n(ForwardIterator first, ForwardIterator last,
1043 Size count, const T& value, BinaryPredicate pred);
1044
1045template <class InputIterator, class OutputIterator>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]1046 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1047 copy(InputIterator first, InputIterator last, OutputIterator result);
1048
1049template<class InputIterator, class OutputIterator, class Predicate>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]1050 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1051 copy_if(InputIterator first, InputIterator last,
1052 OutputIterator result, Predicate pred);
1053
1054template<class InputIterator, class Size, class OutputIterator>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]1055 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1056 copy_n(InputIterator first, Size n, OutputIterator result);
1057
1058template <class BidirectionalIterator1, class BidirectionalIterator2>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]1059 constexpr BidirectionalIterator2 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1060 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
1061 BidirectionalIterator2 result);
1062
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]1063// [alg.move], move
1064template<class InputIterator, class OutputIterator>
1065 constexpr OutputIterator move(InputIterator first, InputIterator last,
1066 OutputIterator result);
1067
1068template<class BidirectionalIterator1, class BidirectionalIterator2>
1069 constexpr BidirectionalIterator2
1070 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
1071 BidirectionalIterator2 result);
1072
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1073template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1074 constexpr ForwardIterator2 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1075 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
1076
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]1077namespace ranges {
1078 template<class I1, class I2>
1079 using swap_ranges_result = in_in_result<I1, I2>;
1080
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]1081template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
1082 requires indirectly_swappable<I1, I2>
1083 constexpr ranges::swap_ranges_result<I1, I2>
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]1084 swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]1085
1086template<input_range R1, input_range R2>
1087 requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
1088 constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
Konstantin Varlamov79a2b4b2022-06-28 18:59:59[diff] [blame]1089 swap_ranges(R1&& r1, R2&& r2);
1090}
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]1091
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1092template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1093 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1094 iter_swap(ForwardIterator1 a, ForwardIterator2 b);
1095
1096template <class InputIterator, class OutputIterator, class UnaryOperation>
Marshall Clow99894b62018-01-19 17:45:39[diff] [blame]1097 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1098 transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
1099
1100template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
Marshall Clow99894b62018-01-19 17:45:39[diff] [blame]1101 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1102 transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
1103 OutputIterator result, BinaryOperation binary_op);
1104
1105template <class ForwardIterator, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1106 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1107 replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
1108
1109template <class ForwardIterator, class Predicate, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1110 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1111 replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
1112
1113template <class InputIterator, class OutputIterator, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1114 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1115 replace_copy(InputIterator first, InputIterator last, OutputIterator result,
1116 const T& old_value, const T& new_value);
1117
1118template <class InputIterator, class OutputIterator, class Predicate, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]1119 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1120 replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
1121
1122template <class ForwardIterator, class T>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1123 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1124 fill(ForwardIterator first, ForwardIterator last, const T& value);
1125
1126template <class OutputIterator, class Size, class T>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1127 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1128 fill_n(OutputIterator first, Size n, const T& value);
1129
1130template <class ForwardIterator, class Generator>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1131 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1132 generate(ForwardIterator first, ForwardIterator last, Generator gen);
1133
1134template <class OutputIterator, class Size, class Generator>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]1135 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1136 generate_n(OutputIterator first, Size n, Generator gen);
1137
1138template <class ForwardIterator, class T>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1139 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1140 remove(ForwardIterator first, ForwardIterator last, const T& value);
1141
1142template <class ForwardIterator, class Predicate>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1143 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1144 remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
1145
1146template <class InputIterator, class OutputIterator, class T>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1147 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1148 remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
1149
1150template <class InputIterator, class OutputIterator, class Predicate>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1151 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1152 remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
1153
1154template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1155 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1156 unique(ForwardIterator first, ForwardIterator last);
1157
1158template <class ForwardIterator, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1159 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1160 unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
1161
1162template <class InputIterator, class OutputIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1163 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1164 unique_copy(InputIterator first, InputIterator last, OutputIterator result);
1165
1166template <class InputIterator, class OutputIterator, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1167 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1168 unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
1169
1170template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1171 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1172 reverse(BidirectionalIterator first, BidirectionalIterator last);
1173
1174template <class BidirectionalIterator, class OutputIterator>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]1175 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1176 reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
1177
1178template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1179 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1180 rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
1181
1182template <class ForwardIterator, class OutputIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1183 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1184 rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
1185
1186template <class RandomAccessIterator>
1187 void
Marshall Clow0f37a412017-03-23 13:43:37[diff] [blame]1188 random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1189
1190template <class RandomAccessIterator, class RandomNumberGenerator>
1191 void
Marshall Clow06965c12014-03-03 06:14:19[diff] [blame]1192 random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
Marshall Clow0f37a412017-03-23 13:43:37[diff] [blame]1193 RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1194
Eric Fiseliere7154702016-08-28 22:14:37[diff] [blame]1195template<class PopulationIterator, class SampleIterator,
1196 class Distance, class UniformRandomBitGenerator>
1197 SampleIterator sample(PopulationIterator first, PopulationIterator last,
1198 SampleIterator out, Distance n,
1199 UniformRandomBitGenerator&& g); // C++17
1200
Howard Hinnantf9d540b2010-05-26 17:49:34[diff] [blame]1201template<class RandomAccessIterator, class UniformRandomNumberGenerator>
1202 void shuffle(RandomAccessIterator first, RandomAccessIterator last,
Howard Hinnantfb340102010-11-18 01:47:02[diff] [blame]1203 UniformRandomNumberGenerator&& g);
Howard Hinnantf9d540b2010-05-26 17:49:34[diff] [blame]1204
Arthur O'Dwyer3fbd3ea2020-12-26 06:39:03[diff] [blame]1205template<class ForwardIterator>
1206 constexpr ForwardIterator
1207 shift_left(ForwardIterator first, ForwardIterator last,
1208 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1209
1210template<class ForwardIterator>
1211 constexpr ForwardIterator
1212 shift_right(ForwardIterator first, ForwardIterator last,
1213 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1214
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1215template <class InputIterator, class Predicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1216 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1217 is_partitioned(InputIterator first, InputIterator last, Predicate pred);
1218
1219template <class ForwardIterator, class Predicate>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1220 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1221 partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1222
1223template <class InputIterator, class OutputIterator1,
1224 class OutputIterator2, class Predicate>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]1225 constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1226 partition_copy(InputIterator first, InputIterator last,
1227 OutputIterator1 out_true, OutputIterator2 out_false,
1228 Predicate pred);
1229
1230template <class ForwardIterator, class Predicate>
1231 ForwardIterator
1232 stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1233
1234template<class ForwardIterator, class Predicate>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1235 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1236 partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
1237
1238template <class ForwardIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1239 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1240 is_sorted(ForwardIterator first, ForwardIterator last);
1241
1242template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1243 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1244 is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
1245
1246template<class ForwardIterator>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]1247 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1248 is_sorted_until(ForwardIterator first, ForwardIterator last);
1249
1250template <class ForwardIterator, class Compare>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]1251 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1252 is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
1253
1254template <class RandomAccessIterator>
Arthur O'Dwyer493f1402020-12-20 20:21:42[diff] [blame]1255 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1256 sort(RandomAccessIterator first, RandomAccessIterator last);
1257
1258template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer493f1402020-12-20 20:21:42[diff] [blame]1259 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1260 sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1261
1262template <class RandomAccessIterator>
1263 void
1264 stable_sort(RandomAccessIterator first, RandomAccessIterator last);
1265
1266template <class RandomAccessIterator, class Compare>
1267 void
1268 stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1269
1270template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1271 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1272 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
1273
1274template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1275 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1276 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
1277
1278template <class InputIterator, class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1279 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1280 partial_sort_copy(InputIterator first, InputIterator last,
1281 RandomAccessIterator result_first, RandomAccessIterator result_last);
1282
1283template <class InputIterator, class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1284 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1285 partial_sort_copy(InputIterator first, InputIterator last,
1286 RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
1287
1288template <class RandomAccessIterator>
Arthur O'Dwyer5d956562021-02-04 23:12:52[diff] [blame]1289 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1290 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
1291
1292template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5d956562021-02-04 23:12:52[diff] [blame]1293 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1294 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
1295
1296template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1297 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1298 lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
1299
1300template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1301 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1302 lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1303
1304template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1305 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1306 upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
1307
1308template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1309 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1310 upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1311
1312template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1313 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1314 equal_range(ForwardIterator first, ForwardIterator last, const T& value);
1315
1316template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1317 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1318 equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1319
1320template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]1321 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1322 binary_search(ForwardIterator first, ForwardIterator last, const T& value);
1323
1324template <class ForwardIterator, class T, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1325 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1326 binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1327
1328template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1329 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1330 merge(InputIterator1 first1, InputIterator1 last1,
1331 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1332
1333template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1334 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1335 merge(InputIterator1 first1, InputIterator1 last1,
1336 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1337
1338template <class BidirectionalIterator>
1339 void
1340 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
1341
1342template <class BidirectionalIterator, class Compare>
1343 void
1344 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
1345
1346template <class InputIterator1, class InputIterator2>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1347 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1348 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1349
1350template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1351 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1352 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
1353
1354template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1355 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1356 set_union(InputIterator1 first1, InputIterator1 last1,
1357 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1358
1359template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1360 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1361 set_union(InputIterator1 first1, InputIterator1 last1,
1362 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1363
1364template <class InputIterator1, class InputIterator2, class OutputIterator>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1365 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1366 set_intersection(InputIterator1 first1, InputIterator1 last1,
1367 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1368
1369template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]1370 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1371 set_intersection(InputIterator1 first1, InputIterator1 last1,
1372 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1373
1374template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1375 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1376 set_difference(InputIterator1 first1, InputIterator1 last1,
1377 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1378
1379template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1380 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1381 set_difference(InputIterator1 first1, InputIterator1 last1,
1382 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1383
1384template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1385 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1386 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
1387 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1388
1389template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]1390 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1391 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
1392 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1393
1394template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1395 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1396 push_heap(RandomAccessIterator first, RandomAccessIterator last);
1397
1398template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1399 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1400 push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1401
1402template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1403 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1404 pop_heap(RandomAccessIterator first, RandomAccessIterator last);
1405
1406template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1407 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1408 pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1409
1410template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1411 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1412 make_heap(RandomAccessIterator first, RandomAccessIterator last);
1413
1414template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1415 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1416 make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1417
1418template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1419 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1420 sort_heap(RandomAccessIterator first, RandomAccessIterator last);
1421
1422template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]1423 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1424 sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1425
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1426template <class RandomAccessIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1427 constexpr bool // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1428 is_heap(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1429
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1430template <class RandomAccessIterator, class Compare>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1431 constexpr bool // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1432 is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1433
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1434template <class RandomAccessIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1435 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1436 is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1437
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1438template <class RandomAccessIterator, class Compare>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]1439 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]1440 is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1441
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1442template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1443 constexpr ForwardIterator // constexpr in C++14
1444 min_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1445
1446template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1447 constexpr ForwardIterator // constexpr in C++14
1448 min_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1449
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1450template <class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1451 constexpr const T& // constexpr in C++14
1452 min(const T& a, const T& b);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1453
1454template <class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1455 constexpr const T& // constexpr in C++14
1456 min(const T& a, const T& b, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1457
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1458template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1459 constexpr T // constexpr in C++14
1460 min(initializer_list<T> t);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1461
1462template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1463 constexpr T // constexpr in C++14
1464 min(initializer_list<T> t, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1465
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]1466template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1467 constexpr const T& clamp(const T& v, const T& lo, const T& hi); // C++17
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]1468
1469template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1470 constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]1471
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1472template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1473 constexpr ForwardIterator // constexpr in C++14
1474 max_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1475
1476template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1477 constexpr ForwardIterator // constexpr in C++14
1478 max_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1479
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1480template <class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1481 constexpr const T& // constexpr in C++14
1482 max(const T& a, const T& b);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1483
1484template <class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1485 constexpr const T& // constexpr in C++14
1486 max(const T& a, const T& b, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1487
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1488template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1489 constexpr T // constexpr in C++14
1490 max(initializer_list<T> t);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1491
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1492template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1493 constexpr T // constexpr in C++14
1494 max(initializer_list<T> t, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1495
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1496template<class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1497 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
1498 minmax_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1499
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1500template<class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1501 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
1502 minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1503
1504template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1505 constexpr pair<const T&, const T&> // constexpr in C++14
1506 minmax(const T& a, const T& b);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1507
1508template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1509 constexpr pair<const T&, const T&> // constexpr in C++14
1510 minmax(const T& a, const T& b, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1511
1512template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1513 constexpr pair<T, T> // constexpr in C++14
1514 minmax(initializer_list<T> t);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]1515
1516template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]1517 constexpr pair<T, T> // constexpr in C++14
1518 minmax(initializer_list<T> t, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1519
1520template <class InputIterator1, class InputIterator2>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]1521 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1522 lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1523
1524template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]1525 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1526 lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
1527 InputIterator2 first2, InputIterator2 last2, Compare comp);
1528
1529template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1530 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1531 next_permutation(BidirectionalIterator first, BidirectionalIterator last);
1532
1533template <class BidirectionalIterator, class Compare>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1534 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1535 next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
1536
1537template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1538 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1539 prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
1540
1541template <class BidirectionalIterator, class Compare>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]1542 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1543 prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1544} // std
1545
1546*/
1547
Louis Dionne385cc252022-03-25 16:55:36[diff] [blame]1548#include <__assert> // all public C++ headers provide the assertion handler
Arthur O'Dwyerea2206d2022-02-04 18:09:30[diff] [blame]1549#include <__bits>
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1550#include <__config>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1551#include <__debug>
Howard Hinnanta1d07d52012-07-26 17:09:09[diff] [blame]1552#include <cstddef>
Arthur O'Dwyerbfbd73f2021-05-19 15:57:04[diff] [blame]1553#include <cstring>
Arthur O'Dwyerbfbd73f2021-05-19 15:57:04[diff] [blame]1554#include <memory>
1555#include <type_traits>
Marshall Clowf56972e2018-09-12 19:41:40[diff] [blame]1556#include <version>
Howard Hinnant5d1a7012013-08-14 18:00:20[diff] [blame]1557
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1558#include <__algorithm/adjacent_find.h>
1559#include <__algorithm/all_of.h>
1560#include <__algorithm/any_of.h>
1561#include <__algorithm/binary_search.h>
1562#include <__algorithm/clamp.h>
1563#include <__algorithm/comp.h>
1564#include <__algorithm/comp_ref_type.h>
1565#include <__algorithm/copy.h>
1566#include <__algorithm/copy_backward.h>
1567#include <__algorithm/copy_if.h>
1568#include <__algorithm/copy_n.h>
1569#include <__algorithm/count.h>
1570#include <__algorithm/count_if.h>
1571#include <__algorithm/equal.h>
1572#include <__algorithm/equal_range.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1573#include <__algorithm/fill.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]1574#include <__algorithm/fill_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1575#include <__algorithm/find.h>
1576#include <__algorithm/find_end.h>
1577#include <__algorithm/find_first_of.h>
1578#include <__algorithm/find_if.h>
1579#include <__algorithm/find_if_not.h>
1580#include <__algorithm/for_each.h>
1581#include <__algorithm/for_each_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1582#include <__algorithm/generate.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]1583#include <__algorithm/generate_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1584#include <__algorithm/half_positive.h>
Nikolas Klauser68f41312022-02-21 22:07:02[diff] [blame]1585#include <__algorithm/in_found_result.h>
Nikolas Klauser1e77b392022-02-11 16:01:58[diff] [blame]1586#include <__algorithm/in_fun_result.h>
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame]1587#include <__algorithm/in_in_out_result.h>
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]1588#include <__algorithm/in_in_result.h>
Nikolas Klauser610979b2022-02-03 01:17:03[diff] [blame]1589#include <__algorithm/in_out_out_result.h>
Konstantin Varlamov8d23b742022-01-11 06:49:37[diff] [blame]1590#include <__algorithm/in_out_result.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1591#include <__algorithm/includes.h>
1592#include <__algorithm/inplace_merge.h>
1593#include <__algorithm/is_heap.h>
1594#include <__algorithm/is_heap_until.h>
1595#include <__algorithm/is_partitioned.h>
1596#include <__algorithm/is_permutation.h>
1597#include <__algorithm/is_sorted.h>
1598#include <__algorithm/is_sorted_until.h>
Christopher Di Bella6adbc832021-06-05 02:47:47[diff] [blame]1599#include <__algorithm/iter_swap.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1600#include <__algorithm/lexicographical_compare.h>
1601#include <__algorithm/lower_bound.h>
1602#include <__algorithm/make_heap.h>
1603#include <__algorithm/max.h>
1604#include <__algorithm/max_element.h>
1605#include <__algorithm/merge.h>
1606#include <__algorithm/min.h>
1607#include <__algorithm/min_element.h>
Nikolas Klauser807766b2022-02-21 21:48:36[diff] [blame]1608#include <__algorithm/min_max_result.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1609#include <__algorithm/minmax.h>
1610#include <__algorithm/minmax_element.h>
1611#include <__algorithm/mismatch.h>
1612#include <__algorithm/move.h>
1613#include <__algorithm/move_backward.h>
1614#include <__algorithm/next_permutation.h>
1615#include <__algorithm/none_of.h>
1616#include <__algorithm/nth_element.h>
1617#include <__algorithm/partial_sort.h>
1618#include <__algorithm/partial_sort_copy.h>
1619#include <__algorithm/partition.h>
1620#include <__algorithm/partition_copy.h>
1621#include <__algorithm/partition_point.h>
1622#include <__algorithm/pop_heap.h>
1623#include <__algorithm/prev_permutation.h>
1624#include <__algorithm/push_heap.h>
Nikolas Klauser916e9052022-06-08 10:14:12[diff] [blame]1625#include <__algorithm/ranges_adjacent_find.h>
Nikolas Klauser0e3dc1a2022-05-26 14:42:46[diff] [blame]1626#include <__algorithm/ranges_all_of.h>
1627#include <__algorithm/ranges_any_of.h>
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]1628#include <__algorithm/ranges_binary_search.h>
Nikolas Klauser1d837502022-04-15 11:43:40[diff] [blame]1629#include <__algorithm/ranges_copy.h>
1630#include <__algorithm/ranges_copy_backward.h>
1631#include <__algorithm/ranges_copy_if.h>
1632#include <__algorithm/ranges_copy_n.h>
Nikolas Klauser1306b102022-04-07 11:02:02[diff] [blame]1633#include <__algorithm/ranges_count.h>
1634#include <__algorithm/ranges_count_if.h>
Nikolas Klauser569d6632022-05-25 09:09:43[diff] [blame]1635#include <__algorithm/ranges_equal.h>
Hui Xie0f6364b82022-07-14 19:35:15[diff] [blame]1636#include <__algorithm/ranges_equal_range.h>
Nikolas Klauser7af89a32022-05-21 16:26:29[diff] [blame]1637#include <__algorithm/ranges_fill.h>
1638#include <__algorithm/ranges_fill_n.h>
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]1639#include <__algorithm/ranges_find.h>
Nikolas Klauser101d1e92022-07-13 16:07:26[diff] [blame]1640#include <__algorithm/ranges_find_end.h>
Nikolas Klauserb79b2b62022-06-06 11:57:34[diff] [blame]1641#include <__algorithm/ranges_find_first_of.h>
Nikolas Klauseree0f8c42022-03-12 00:45:35[diff] [blame]1642#include <__algorithm/ranges_find_if.h>
1643#include <__algorithm/ranges_find_if_not.h>
Nikolas Klauser80045e92022-05-04 18:27:07[diff] [blame]1644#include <__algorithm/ranges_for_each.h>
1645#include <__algorithm/ranges_for_each_n.h>
Konstantin Varlamovead73022022-07-26 22:50:14[diff] [blame]1646#include <__algorithm/ranges_generate.h>
1647#include <__algorithm/ranges_generate_n.h>
Hui Xiec5599642022-07-19 19:54:35[diff] [blame]1648#include <__algorithm/ranges_includes.h>
Hui Xie8a617492022-07-27 12:20:16[diff] [blame]1649#include <__algorithm/ranges_inplace_merge.h>
Konstantin Varlamovd406c642022-07-26 23:11:09[diff] [blame]1650#include <__algorithm/ranges_is_heap.h>
1651#include <__algorithm/ranges_is_heap_until.h>
Nikolas Klauser37ba1b92022-05-04 12:19:09[diff] [blame]1652#include <__algorithm/ranges_is_partitioned.h>
Nikolas Klauser11e3ad22022-05-26 14:08:55[diff] [blame]1653#include <__algorithm/ranges_is_sorted.h>
1654#include <__algorithm/ranges_is_sorted_until.h>
Nikolas Klauserafd5a4f2022-06-15 14:24:43[diff] [blame]1655#include <__algorithm/ranges_lexicographical_compare.h>
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]1656#include <__algorithm/ranges_lower_bound.h>
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]1657#include <__algorithm/ranges_make_heap.h>
Nikolas Klausere476df52022-04-03 07:17:01[diff] [blame]1658#include <__algorithm/ranges_max.h>
Nikolas Klauser205557c2022-03-07 16:01:52[diff] [blame]1659#include <__algorithm/ranges_max_element.h>
Hui Xie25607d12022-06-26 15:13:43[diff] [blame]1660#include <__algorithm/ranges_merge.h>
Nikolas Klauserf83d8332022-03-18 01:57:08[diff] [blame]1661#include <__algorithm/ranges_min.h>
Nikolas Klauser3b470d12022-02-11 12:11:57[diff] [blame]1662#include <__algorithm/ranges_min_element.h>
Nikolas Klauser58d9ab72022-04-13 20:59:09[diff] [blame]1663#include <__algorithm/ranges_minmax.h>
1664#include <__algorithm/ranges_minmax_element.h>
Nikolas Klauserc2cd15a2022-03-08 22:12:35[diff] [blame]1665#include <__algorithm/ranges_mismatch.h>
Nikolas Klauser2c3bbac2022-06-23 10:23:41[diff] [blame]1666#include <__algorithm/ranges_move.h>
1667#include <__algorithm/ranges_move_backward.h>
Nikolas Klauser0e3dc1a2022-05-26 14:42:46[diff] [blame]1668#include <__algorithm/ranges_none_of.h>
Konstantin Varlamov23c73282022-07-08 03:35:51[diff] [blame]1669#include <__algorithm/ranges_nth_element.h>
varconst5dd19ad2022-07-20 03:10:02[diff] [blame]1670#include <__algorithm/ranges_partial_sort.h>
Konstantin Varlamov8ed702b2022-07-19 04:05:51[diff] [blame]1671#include <__algorithm/ranges_partition.h>
Konstantin Varlamov065202f2022-07-20 08:57:13[diff] [blame]1672#include <__algorithm/ranges_partition_copy.h>
1673#include <__algorithm/ranges_partition_point.h>
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]1674#include <__algorithm/ranges_pop_heap.h>
1675#include <__algorithm/ranges_push_heap.h>
Nikolas Klauserf8cbe3cdf2022-07-06 12:03:00[diff] [blame]1676#include <__algorithm/ranges_remove.h>
1677#include <__algorithm/ranges_remove_if.h>
Nikolas Klauserff6d5de2022-06-07 07:42:10[diff] [blame]1678#include <__algorithm/ranges_replace.h>
1679#include <__algorithm/ranges_replace_if.h>
Nikolas Klauser1d1a1912022-05-24 08:32:50[diff] [blame]1680#include <__algorithm/ranges_reverse.h>
Nikolas Klauser7d426a32022-07-11 15:07:35[diff] [blame]1681#include <__algorithm/ranges_reverse_copy.h>
1682#include <__algorithm/ranges_rotate_copy.h>
Nikolas Klauser101d1e92022-07-13 16:07:26[diff] [blame]1683#include <__algorithm/ranges_search.h>
1684#include <__algorithm/ranges_search_n.h>
Hui Xie1cdec6c2022-06-26 15:13:43[diff] [blame]1685#include <__algorithm/ranges_set_difference.h>
Hui Xie96b674f2022-07-08 14:21:40[diff] [blame]1686#include <__algorithm/ranges_set_intersection.h>
Hui Xiea5c06382022-07-11 22:39:59[diff] [blame]1687#include <__algorithm/ranges_set_symmetric_difference.h>
Hui Xie3151b952022-07-13 16:20:22[diff] [blame]1688#include <__algorithm/ranges_set_union.h>
Konstantin Varlamov14cf74d2022-07-22 16:58:56[diff] [blame]1689#include <__algorithm/ranges_shuffle.h>
Konstantin Varlamovff3989e2022-06-16 22:20:53[diff] [blame]1690#include <__algorithm/ranges_sort.h>
Konstantin Varlamovc945bd02022-07-08 20:46:27[diff] [blame]1691#include <__algorithm/ranges_sort_heap.h>
Konstantin Varlamov8ed702b2022-07-19 04:05:51[diff] [blame]1692#include <__algorithm/ranges_stable_partition.h>
Konstantin Varlamov94c7b892022-07-01 23:34:08[diff] [blame]1693#include <__algorithm/ranges_stable_sort.h>
Nikolas Klauser9d905312022-02-10 12:33:03[diff] [blame]1694#include <__algorithm/ranges_swap_ranges.h>
Nikolas Klauser3ba85482022-04-05 09:05:36[diff] [blame]1695#include <__algorithm/ranges_transform.h>
Hui Xie72f57e32022-07-23 00:44:25[diff] [blame^]1696#include <__algorithm/ranges_unique.h>
1697#include <__algorithm/ranges_unique_copy.h>
Nikolas Klauser81715862022-06-05 19:15:16[diff] [blame]1698#include <__algorithm/ranges_upper_bound.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1699#include <__algorithm/remove.h>
1700#include <__algorithm/remove_copy.h>
1701#include <__algorithm/remove_copy_if.h>
1702#include <__algorithm/remove_if.h>
1703#include <__algorithm/replace.h>
1704#include <__algorithm/replace_copy.h>
1705#include <__algorithm/replace_copy_if.h>
1706#include <__algorithm/replace_if.h>
1707#include <__algorithm/reverse.h>
1708#include <__algorithm/reverse_copy.h>
1709#include <__algorithm/rotate.h>
1710#include <__algorithm/rotate_copy.h>
1711#include <__algorithm/sample.h>
1712#include <__algorithm/search.h>
1713#include <__algorithm/search_n.h>
1714#include <__algorithm/set_difference.h>
1715#include <__algorithm/set_intersection.h>
1716#include <__algorithm/set_symmetric_difference.h>
1717#include <__algorithm/set_union.h>
1718#include <__algorithm/shift_left.h>
1719#include <__algorithm/shift_right.h>
1720#include <__algorithm/shuffle.h>
1721#include <__algorithm/sift_down.h>
1722#include <__algorithm/sort.h>
1723#include <__algorithm/sort_heap.h>
1724#include <__algorithm/stable_partition.h>
1725#include <__algorithm/stable_sort.h>
Christopher Di Bella6adbc832021-06-05 02:47:47[diff] [blame]1726#include <__algorithm/swap_ranges.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1727#include <__algorithm/transform.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1728#include <__algorithm/unique.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]1729#include <__algorithm/unique_copy.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]1730#include <__algorithm/unwrap_iter.h>
1731#include <__algorithm/upper_bound.h>
Eric Fiselierc1bd9192014-08-10 23:53:08[diff] [blame]1732
Louis Dionnede4a57c2022-06-27 19:53:41[diff] [blame]1733#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
1734# include <chrono>
1735# include <iterator>
1736# include <utility>
1737#endif
1738
Nikolas Klauserdb1978b2022-06-16 20:43:46[diff] [blame]1739// standard-mandated includes
1740#include <initializer_list>
1741
Howard Hinnant073458b2011-10-17 20:05:10[diff] [blame]1742#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Arthur O'Dwyerfa6b9e42022-02-02 01:16:40[diff] [blame]1743# pragma GCC system_header
Howard Hinnant073458b2011-10-17 20:05:10[diff] [blame]1744#endif
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]1745
Louis Dionne0a06eb92019-08-05 18:29:14[diff] [blame]1746#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
Louis Dionne95689242019-08-06 21:11:24[diff] [blame]1747# include <__pstl_algorithm>
Louis Dionne0a06eb92019-08-05 18:29:14[diff] [blame]1748#endif
1749
Louis Dionne4cd6ca12021-04-20 16:03:32[diff] [blame]1750#endif // _LIBCPP_ALGORITHM