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