Google Git
Sign in
chromium / external / github.com / llvm / llvm-project.git / f3514af492ee14a9f7f8cb88acc7b93ea0bb0ffc / . / libcxx / include / algorithm
blob: e5f1030be201161d818338b14cbd34ea77b90d69 [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 {
22 template <class I1, class I2>
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame^]23 struct in_in_result; // since C++20
24
25 template <class I1, class I2, class O>
26 struct in_in_out_result; // since C++20
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]27}
28
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]29template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]30 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]31 all_of(InputIterator first, InputIterator last, Predicate pred);
32
33template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]34 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]35 any_of(InputIterator first, InputIterator last, Predicate pred);
36
37template <class InputIterator, class Predicate>
Marshall Clow706ffef2018-01-15 17:20:36[diff] [blame]38 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]39 none_of(InputIterator first, InputIterator last, Predicate pred);
40
41template <class InputIterator, class Function>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]42 constexpr Function // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]43 for_each(InputIterator first, InputIterator last, Function f);
44
Marshall Clowd5c65ff2017-05-25 02:29:54[diff] [blame]45template<class InputIterator, class Size, class Function>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]46 constexpr InputIterator // constexpr in C++20
47 for_each_n(InputIterator first, Size n, Function f); // C++17
Marshall Clowd5c65ff2017-05-25 02:29:54[diff] [blame]48
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]49template <class InputIterator, class T>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]50 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]51 find(InputIterator first, InputIterator last, const T& value);
52
53template <class InputIterator, class Predicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]54 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]55 find_if(InputIterator first, InputIterator last, Predicate pred);
56
57template<class InputIterator, class Predicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]58 constexpr InputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]59 find_if_not(InputIterator first, InputIterator last, Predicate pred);
60
61template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]62 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]63 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
64 ForwardIterator2 first2, ForwardIterator2 last2);
65
66template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]67 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]68 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
69 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
70
71template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]72 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]73 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
74 ForwardIterator2 first2, ForwardIterator2 last2);
75
76template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]77 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]78 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
79 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
80
81template <class ForwardIterator>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]82 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]83 adjacent_find(ForwardIterator first, ForwardIterator last);
84
85template <class ForwardIterator, class BinaryPredicate>
Marshall Clow86944282018-01-15 19:26:05[diff] [blame]86 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]87 adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
88
89template <class InputIterator, class T>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]90 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]91 count(InputIterator first, InputIterator last, const T& value);
92
93template <class InputIterator, class Predicate>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]94 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]95 count_if(InputIterator first, InputIterator last, Predicate pred);
96
97template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]98 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]99 mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
100
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]101template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]102 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Aditya Kumar331fb802016-08-25 11:52:38[diff] [blame]103 mismatch(InputIterator1 first1, InputIterator1 last1,
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]104 InputIterator2 first2, InputIterator2 last2); // **C++14**
105
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]106template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]107 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]108 mismatch(InputIterator1 first1, InputIterator1 last1,
109 InputIterator2 first2, BinaryPredicate pred);
110
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]111template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]112 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]113 mismatch(InputIterator1 first1, InputIterator1 last1,
114 InputIterator2 first2, InputIterator2 last2,
115 BinaryPredicate pred); // **C++14**
116
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]117template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]118 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]119 equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
120
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]121template <class InputIterator1, class InputIterator2>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]122 constexpr bool // constexpr in C++20
Aditya Kumar331fb802016-08-25 11:52:38[diff] [blame]123 equal(InputIterator1 first1, InputIterator1 last1,
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]124 InputIterator2 first2, InputIterator2 last2); // **C++14**
125
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]126template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]127 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]128 equal(InputIterator1 first1, InputIterator1 last1,
129 InputIterator2 first2, BinaryPredicate pred);
130
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]131template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow6538e28d2018-01-16 02:04:10[diff] [blame]132 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]133 equal(InputIterator1 first1, InputIterator1 last1,
134 InputIterator2 first2, InputIterator2 last2,
135 BinaryPredicate pred); // **C++14**
136
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]137template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]138 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]139 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
140 ForwardIterator2 first2);
141
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]142template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]143 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]144 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
145 ForwardIterator2 first2, ForwardIterator2 last2); // **C++14**
146
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]147template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]148 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]149 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
150 ForwardIterator2 first2, BinaryPredicate pred);
151
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]152template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]153 constexpr bool // constexpr in C++20
Marshall Clow0b0bbd22013-05-09 21:14:23[diff] [blame]154 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
155 ForwardIterator2 first2, ForwardIterator2 last2,
156 BinaryPredicate pred); // **C++14**
157
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]158template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]159 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]160 search(ForwardIterator1 first1, ForwardIterator1 last1,
161 ForwardIterator2 first2, ForwardIterator2 last2);
162
163template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]164 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]165 search(ForwardIterator1 first1, ForwardIterator1 last1,
166 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
167
168template <class ForwardIterator, class Size, class T>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]169 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]170 search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
171
172template <class ForwardIterator, class Size, class T, class BinaryPredicate>
Marshall Clow12f0a772018-01-16 15:48:27[diff] [blame]173 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]174 search_n(ForwardIterator first, ForwardIterator last,
175 Size count, const T& value, BinaryPredicate pred);
176
177template <class InputIterator, class OutputIterator>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]178 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]179 copy(InputIterator first, InputIterator last, OutputIterator result);
180
181template<class InputIterator, class OutputIterator, class Predicate>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]182 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]183 copy_if(InputIterator first, InputIterator last,
184 OutputIterator result, Predicate pred);
185
186template<class InputIterator, class Size, class OutputIterator>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]187 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]188 copy_n(InputIterator first, Size n, OutputIterator result);
189
190template <class BidirectionalIterator1, class BidirectionalIterator2>
Louis Dionne13c90a52019-11-06 12:02:41[diff] [blame]191 constexpr BidirectionalIterator2 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]192 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
193 BidirectionalIterator2 result);
194
195template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]196 constexpr ForwardIterator2 // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]197 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
198
199template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]200 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]201 iter_swap(ForwardIterator1 a, ForwardIterator2 b);
202
203template <class InputIterator, class OutputIterator, class UnaryOperation>
Marshall Clow99894b62018-01-19 17:45:39[diff] [blame]204 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]205 transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
206
207template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
Marshall Clow99894b62018-01-19 17:45:39[diff] [blame]208 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]209 transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
210 OutputIterator result, BinaryOperation binary_op);
211
212template <class ForwardIterator, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]213 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]214 replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
215
216template <class ForwardIterator, class Predicate, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]217 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]218 replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
219
220template <class InputIterator, class OutputIterator, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]221 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]222 replace_copy(InputIterator first, InputIterator last, OutputIterator result,
223 const T& old_value, const T& new_value);
224
225template <class InputIterator, class OutputIterator, class Predicate, class T>
Marshall Clow12c74232018-01-19 18:07:29[diff] [blame]226 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]227 replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
228
229template <class ForwardIterator, class T>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]230 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]231 fill(ForwardIterator first, ForwardIterator last, const T& value);
232
233template <class OutputIterator, class Size, class T>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]234 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]235 fill_n(OutputIterator first, Size n, const T& value);
236
237template <class ForwardIterator, class Generator>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]238 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]239 generate(ForwardIterator first, ForwardIterator last, Generator gen);
240
241template <class OutputIterator, class Size, class Generator>
Marshall Clow4bfb9312018-01-20 20:14:32[diff] [blame]242 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]243 generate_n(OutputIterator first, Size n, Generator gen);
244
245template <class ForwardIterator, class T>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]246 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]247 remove(ForwardIterator first, ForwardIterator last, const T& value);
248
249template <class ForwardIterator, class Predicate>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]250 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]251 remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
252
253template <class InputIterator, class OutputIterator, class T>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]254 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]255 remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
256
257template <class InputIterator, class OutputIterator, class Predicate>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]258 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]259 remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
260
261template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]262 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]263 unique(ForwardIterator first, ForwardIterator last);
264
265template <class ForwardIterator, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]266 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]267 unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
268
269template <class InputIterator, class OutputIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]270 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]271 unique_copy(InputIterator first, InputIterator last, OutputIterator result);
272
273template <class InputIterator, class OutputIterator, class BinaryPredicate>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]274 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]275 unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
276
277template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]278 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]279 reverse(BidirectionalIterator first, BidirectionalIterator last);
280
281template <class BidirectionalIterator, class OutputIterator>
Marshall Clowe8ea8292018-01-22 21:43:04[diff] [blame]282 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]283 reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
284
285template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]286 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]287 rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
288
289template <class ForwardIterator, class OutputIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]290 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]291 rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
292
293template <class RandomAccessIterator>
294 void
Marshall Clow0f37a412017-03-23 13:43:37[diff] [blame]295 random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]296
297template <class RandomAccessIterator, class RandomNumberGenerator>
298 void
Marshall Clow06965c12014-03-03 06:14:19[diff] [blame]299 random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
Marshall Clow0f37a412017-03-23 13:43:37[diff] [blame]300 RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]301
Eric Fiseliere7154702016-08-28 22:14:37[diff] [blame]302template<class PopulationIterator, class SampleIterator,
303 class Distance, class UniformRandomBitGenerator>
304 SampleIterator sample(PopulationIterator first, PopulationIterator last,
305 SampleIterator out, Distance n,
306 UniformRandomBitGenerator&& g); // C++17
307
Howard Hinnantf9d540b2010-05-26 17:49:34[diff] [blame]308template<class RandomAccessIterator, class UniformRandomNumberGenerator>
309 void shuffle(RandomAccessIterator first, RandomAccessIterator last,
Howard Hinnantfb340102010-11-18 01:47:02[diff] [blame]310 UniformRandomNumberGenerator&& g);
Howard Hinnantf9d540b2010-05-26 17:49:34[diff] [blame]311
Arthur O'Dwyer3fbd3ea2020-12-26 06:39:03[diff] [blame]312template<class ForwardIterator>
313 constexpr ForwardIterator
314 shift_left(ForwardIterator first, ForwardIterator last,
315 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
316
317template<class ForwardIterator>
318 constexpr ForwardIterator
319 shift_right(ForwardIterator first, ForwardIterator last,
320 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
321
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]322template <class InputIterator, class Predicate>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]323 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]324 is_partitioned(InputIterator first, InputIterator last, Predicate pred);
325
326template <class ForwardIterator, class Predicate>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]327 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]328 partition(ForwardIterator first, ForwardIterator last, Predicate pred);
329
330template <class InputIterator, class OutputIterator1,
331 class OutputIterator2, class Predicate>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]332 constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]333 partition_copy(InputIterator first, InputIterator last,
334 OutputIterator1 out_true, OutputIterator2 out_false,
335 Predicate pred);
336
337template <class ForwardIterator, class Predicate>
338 ForwardIterator
339 stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
340
341template<class ForwardIterator, class Predicate>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]342 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]343 partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
344
345template <class ForwardIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]346 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]347 is_sorted(ForwardIterator first, ForwardIterator last);
348
349template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]350 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]351 is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
352
353template<class ForwardIterator>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]354 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]355 is_sorted_until(ForwardIterator first, ForwardIterator last);
356
357template <class ForwardIterator, class Compare>
Marshall Clow056f15e2018-01-15 19:40:34[diff] [blame]358 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]359 is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
360
361template <class RandomAccessIterator>
Arthur O'Dwyer493f1402020-12-20 20:21:42[diff] [blame]362 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]363 sort(RandomAccessIterator first, RandomAccessIterator last);
364
365template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer493f1402020-12-20 20:21:42[diff] [blame]366 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]367 sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
368
369template <class RandomAccessIterator>
370 void
371 stable_sort(RandomAccessIterator first, RandomAccessIterator last);
372
373template <class RandomAccessIterator, class Compare>
374 void
375 stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
376
377template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]378 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]379 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
380
381template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]382 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]383 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
384
385template <class InputIterator, class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]386 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]387 partial_sort_copy(InputIterator first, InputIterator last,
388 RandomAccessIterator result_first, RandomAccessIterator result_last);
389
390template <class InputIterator, class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]391 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]392 partial_sort_copy(InputIterator first, InputIterator last,
393 RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
394
395template <class RandomAccessIterator>
Arthur O'Dwyer5d956562021-02-04 23:12:52[diff] [blame]396 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]397 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
398
399template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5d956562021-02-04 23:12:52[diff] [blame]400 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]401 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
402
403template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]404 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]405 lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
406
407template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]408 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]409 lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
410
411template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]412 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]413 upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
414
415template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]416 constexpr ForwardIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]417 upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
418
419template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]420 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]421 equal_range(ForwardIterator first, ForwardIterator last, const T& value);
422
423template <class ForwardIterator, class T, class Compare>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]424 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]425 equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
426
427template <class ForwardIterator, class T>
Marshall Clowd57c03d2018-01-16 02:34:41[diff] [blame]428 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]429 binary_search(ForwardIterator first, ForwardIterator last, const T& value);
430
431template <class ForwardIterator, class T, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]432 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]433 binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
434
435template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]436 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]437 merge(InputIterator1 first1, InputIterator1 last1,
438 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
439
440template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]441 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]442 merge(InputIterator1 first1, InputIterator1 last1,
443 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
444
445template <class BidirectionalIterator>
446 void
447 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
448
449template <class BidirectionalIterator, class Compare>
450 void
451 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
452
453template <class InputIterator1, class InputIterator2>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]454 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]455 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
456
457template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]458 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]459 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
460
461template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]462 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]463 set_union(InputIterator1 first1, InputIterator1 last1,
464 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
465
466template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]467 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]468 set_union(InputIterator1 first1, InputIterator1 last1,
469 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
470
471template <class InputIterator1, class InputIterator2, class OutputIterator>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]472 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]473 set_intersection(InputIterator1 first1, InputIterator1 last1,
474 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
475
476template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Marshall Clow8da1a482018-01-22 23:10:40[diff] [blame]477 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]478 set_intersection(InputIterator1 first1, InputIterator1 last1,
479 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
480
481template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]482 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]483 set_difference(InputIterator1 first1, InputIterator1 last1,
484 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
485
486template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]487 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]488 set_difference(InputIterator1 first1, InputIterator1 last1,
489 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
490
491template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]492 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]493 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
494 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
495
496template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer14098cf2020-12-04 18:47:12[diff] [blame]497 constexpr OutputIterator // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]498 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
499 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
500
501template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]502 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]503 push_heap(RandomAccessIterator first, RandomAccessIterator last);
504
505template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]506 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]507 push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
508
509template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]510 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]511 pop_heap(RandomAccessIterator first, RandomAccessIterator last);
512
513template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]514 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]515 pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
516
517template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]518 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]519 make_heap(RandomAccessIterator first, RandomAccessIterator last);
520
521template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]522 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]523 make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
524
525template <class RandomAccessIterator>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]526 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]527 sort_heap(RandomAccessIterator first, RandomAccessIterator last);
528
529template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer5386aa22020-12-17 05:26:18[diff] [blame]530 constexpr void // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]531 sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
532
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]533template <class RandomAccessIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]534 constexpr bool // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]535 is_heap(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]536
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]537template <class RandomAccessIterator, class Compare>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]538 constexpr bool // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]539 is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]540
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]541template <class RandomAccessIterator>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]542 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]543 is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]544
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]545template <class RandomAccessIterator, class Compare>
Marshall Clow49c76432018-01-15 16:16:32[diff] [blame]546 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantb3371f62010-08-22 00:02:43[diff] [blame]547 is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]548
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]549template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]550 constexpr ForwardIterator // constexpr in C++14
551 min_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]552
553template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]554 constexpr ForwardIterator // constexpr in C++14
555 min_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]556
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]557template <class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]558 constexpr const T& // constexpr in C++14
559 min(const T& a, const T& b);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]560
561template <class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]562 constexpr const T& // constexpr in C++14
563 min(const T& a, const T& b, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]564
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]565template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]566 constexpr T // constexpr in C++14
567 min(initializer_list<T> t);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]568
569template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]570 constexpr T // constexpr in C++14
571 min(initializer_list<T> t, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]572
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]573template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]574 constexpr const T& clamp(const T& v, const T& lo, const T& hi); // C++17
Marshall Clow146c14a2016-03-07 22:43:49[diff] [blame]575
576template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]577 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]578
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]579template <class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]580 constexpr ForwardIterator // constexpr in C++14
581 max_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]582
583template <class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]584 constexpr ForwardIterator // constexpr in C++14
585 max_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]586
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]587template <class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]588 constexpr const T& // constexpr in C++14
589 max(const T& a, const T& b);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]590
591template <class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]592 constexpr const T& // constexpr in C++14
593 max(const T& a, const T& b, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]594
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]595template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]596 constexpr T // constexpr in C++14
597 max(initializer_list<T> t);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]598
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]599template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]600 constexpr T // constexpr in C++14
601 max(initializer_list<T> t, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]602
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]603template<class ForwardIterator>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]604 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
605 minmax_element(ForwardIterator first, ForwardIterator last);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]606
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]607template<class ForwardIterator, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]608 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
609 minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]610
611template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]612 constexpr pair<const T&, const T&> // constexpr in C++14
613 minmax(const T& a, const T& b);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]614
615template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]616 constexpr pair<const T&, const T&> // constexpr in C++14
617 minmax(const T& a, const T& b, Compare comp);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]618
619template<class T>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]620 constexpr pair<T, T> // constexpr in C++14
621 minmax(initializer_list<T> t);
Howard Hinnant4eb27b72010-08-21 20:10:01[diff] [blame]622
623template<class T, class Compare>
Arthur O'Dwyerb8bc4e12020-12-03 01:02:18[diff] [blame]624 constexpr pair<T, T> // constexpr in C++14
625 minmax(initializer_list<T> t, Compare comp);
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]626
627template <class InputIterator1, class InputIterator2>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]628 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]629 lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
630
631template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow1b9a4ff2018-01-22 20:44:33[diff] [blame]632 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]633 lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
634 InputIterator2 first2, InputIterator2 last2, Compare comp);
635
636template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]637 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]638 next_permutation(BidirectionalIterator first, BidirectionalIterator last);
639
640template <class BidirectionalIterator, class Compare>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]641 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]642 next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
643
644template <class BidirectionalIterator>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]645 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]646 prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
647
648template <class BidirectionalIterator, class Compare>
Arthur O'Dwyerf851db32020-12-17 05:01:08[diff] [blame]649 constexpr bool // constexpr in C++20
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]650 prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
651
Konstantin Varlamov8d23b742022-01-11 06:49:37[diff] [blame]652namespace ranges {
653// [algorithms.results], algorithm result types
654template<class InputIterator, class OutputIterator>
655 struct in_out_result;
656}
657
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]658} // std
659
660*/
661
Nikolas Klausercf54cb22022-01-03 00:24:09[diff] [blame]662#include <__bits> // __libcpp_clz
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]663#include <__config>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]664#include <__debug>
Howard Hinnanta1d07d52012-07-26 17:09:09[diff] [blame]665#include <cstddef>
Arthur O'Dwyerbfbd73f2021-05-19 15:57:04[diff] [blame]666#include <cstring>
667#include <functional>
668#include <initializer_list>
Arthur O'Dwyerbfbd73f2021-05-19 15:57:04[diff] [blame]669#include <iterator>
670#include <memory>
671#include <type_traits>
672#include <utility> // swap_ranges
Marshall Clowf56972e2018-09-12 19:41:40[diff] [blame]673#include <version>
Howard Hinnant5d1a7012013-08-14 18:00:20[diff] [blame]674
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]675#include <__algorithm/adjacent_find.h>
676#include <__algorithm/all_of.h>
677#include <__algorithm/any_of.h>
678#include <__algorithm/binary_search.h>
679#include <__algorithm/clamp.h>
680#include <__algorithm/comp.h>
681#include <__algorithm/comp_ref_type.h>
682#include <__algorithm/copy.h>
683#include <__algorithm/copy_backward.h>
684#include <__algorithm/copy_if.h>
685#include <__algorithm/copy_n.h>
686#include <__algorithm/count.h>
687#include <__algorithm/count_if.h>
688#include <__algorithm/equal.h>
689#include <__algorithm/equal_range.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]690#include <__algorithm/fill.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]691#include <__algorithm/fill_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]692#include <__algorithm/find.h>
693#include <__algorithm/find_end.h>
694#include <__algorithm/find_first_of.h>
695#include <__algorithm/find_if.h>
696#include <__algorithm/find_if_not.h>
697#include <__algorithm/for_each.h>
698#include <__algorithm/for_each_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]699#include <__algorithm/generate.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]700#include <__algorithm/generate_n.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]701#include <__algorithm/half_positive.h>
Nikolas Klauserf3514af2022-01-25 10:21:47[diff] [blame^]702#include <__algorithm/in_in_out_result.h>
Nikolas Klauserd3729bb2022-01-14 01:55:51[diff] [blame]703#include <__algorithm/in_in_result.h>
Konstantin Varlamov8d23b742022-01-11 06:49:37[diff] [blame]704#include <__algorithm/in_out_result.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]705#include <__algorithm/includes.h>
706#include <__algorithm/inplace_merge.h>
707#include <__algorithm/is_heap.h>
708#include <__algorithm/is_heap_until.h>
709#include <__algorithm/is_partitioned.h>
710#include <__algorithm/is_permutation.h>
711#include <__algorithm/is_sorted.h>
712#include <__algorithm/is_sorted_until.h>
Christopher Di Bella6adbc832021-06-05 02:47:47[diff] [blame]713#include <__algorithm/iter_swap.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]714#include <__algorithm/lexicographical_compare.h>
715#include <__algorithm/lower_bound.h>
716#include <__algorithm/make_heap.h>
717#include <__algorithm/max.h>
718#include <__algorithm/max_element.h>
719#include <__algorithm/merge.h>
720#include <__algorithm/min.h>
721#include <__algorithm/min_element.h>
722#include <__algorithm/minmax.h>
723#include <__algorithm/minmax_element.h>
724#include <__algorithm/mismatch.h>
725#include <__algorithm/move.h>
726#include <__algorithm/move_backward.h>
727#include <__algorithm/next_permutation.h>
728#include <__algorithm/none_of.h>
729#include <__algorithm/nth_element.h>
730#include <__algorithm/partial_sort.h>
731#include <__algorithm/partial_sort_copy.h>
732#include <__algorithm/partition.h>
733#include <__algorithm/partition_copy.h>
734#include <__algorithm/partition_point.h>
735#include <__algorithm/pop_heap.h>
736#include <__algorithm/prev_permutation.h>
737#include <__algorithm/push_heap.h>
738#include <__algorithm/remove.h>
739#include <__algorithm/remove_copy.h>
740#include <__algorithm/remove_copy_if.h>
741#include <__algorithm/remove_if.h>
742#include <__algorithm/replace.h>
743#include <__algorithm/replace_copy.h>
744#include <__algorithm/replace_copy_if.h>
745#include <__algorithm/replace_if.h>
746#include <__algorithm/reverse.h>
747#include <__algorithm/reverse_copy.h>
748#include <__algorithm/rotate.h>
749#include <__algorithm/rotate_copy.h>
750#include <__algorithm/sample.h>
751#include <__algorithm/search.h>
752#include <__algorithm/search_n.h>
753#include <__algorithm/set_difference.h>
754#include <__algorithm/set_intersection.h>
755#include <__algorithm/set_symmetric_difference.h>
756#include <__algorithm/set_union.h>
757#include <__algorithm/shift_left.h>
758#include <__algorithm/shift_right.h>
759#include <__algorithm/shuffle.h>
760#include <__algorithm/sift_down.h>
761#include <__algorithm/sort.h>
762#include <__algorithm/sort_heap.h>
763#include <__algorithm/stable_partition.h>
764#include <__algorithm/stable_sort.h>
Christopher Di Bella6adbc832021-06-05 02:47:47[diff] [blame]765#include <__algorithm/swap_ranges.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]766#include <__algorithm/transform.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]767#include <__algorithm/unique.h>
Arthur O'Dwyer4d81a462022-01-07 14:45:05[diff] [blame]768#include <__algorithm/unique_copy.h>
Louis Dionne134723e2021-06-17 15:30:11[diff] [blame]769#include <__algorithm/unwrap_iter.h>
770#include <__algorithm/upper_bound.h>
Eric Fiselierc1bd9192014-08-10 23:53:08[diff] [blame]771
Howard Hinnant073458b2011-10-17 20:05:10[diff] [blame]772#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]773#pragma GCC system_header
Howard Hinnant073458b2011-10-17 20:05:10[diff] [blame]774#endif
Howard Hinnant3e519522010-05-11 19:42:16[diff] [blame]775
Louis Dionne0a06eb92019-08-05 18:29:14[diff] [blame]776#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
Louis Dionne95689242019-08-06 21:11:24[diff] [blame]777# include <__pstl_algorithm>
Louis Dionne0a06eb92019-08-05 18:29:14[diff] [blame]778#endif
779
Louis Dionne4cd6ca12021-04-20 16:03:32[diff] [blame]780#endif // _LIBCPP_ALGORITHM