blob: a6fceaa91292f8465d8fc372b992d26ab75c7c3b [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001// -*- C++ -*-
2//===-------------------------- algorithm ---------------------------------===//
3//
Chandler Carruthd2012102019-01-19 10:56:40 +00004// 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 Hinnantc51e1022010-05-11 19:42:16 +00007//
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
21template <class InputIterator, class Predicate>
Marshall Clowd607fdb2018-01-15 17:20:36 +000022 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000023 all_of(InputIterator first, InputIterator last, Predicate pred);
24
25template <class InputIterator, class Predicate>
Marshall Clowd607fdb2018-01-15 17:20:36 +000026 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000027 any_of(InputIterator first, InputIterator last, Predicate pred);
28
29template <class InputIterator, class Predicate>
Marshall Clowd607fdb2018-01-15 17:20:36 +000030 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000031 none_of(InputIterator first, InputIterator last, Predicate pred);
32
33template <class InputIterator, class Function>
Marshall Clow5492c8a2018-01-22 20:44:33 +000034 constexpr Function // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000035 for_each(InputIterator first, InputIterator last, Function f);
36
Marshall Clowde0169c2017-05-25 02:29:54 +000037template<class InputIterator, class Size, class Function>
Marshall Clow5492c8a2018-01-22 20:44:33 +000038 constexpr InputIterator // constexpr in C++20
39 for_each_n(InputIterator first, Size n, Function f); // C++17
Marshall Clowde0169c2017-05-25 02:29:54 +000040
Howard Hinnantc51e1022010-05-11 19:42:16 +000041template <class InputIterator, class T>
Marshall Clowee0161e2018-01-15 19:26:05 +000042 constexpr InputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000043 find(InputIterator first, InputIterator last, const T& value);
44
45template <class InputIterator, class Predicate>
Marshall Clowee0161e2018-01-15 19:26:05 +000046 constexpr InputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000047 find_if(InputIterator first, InputIterator last, Predicate pred);
48
49template<class InputIterator, class Predicate>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -050050 constexpr InputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000051 find_if_not(InputIterator first, InputIterator last, Predicate pred);
52
53template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -050054 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000055 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
56 ForwardIterator2 first2, ForwardIterator2 last2);
57
58template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -050059 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000060 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
61 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
62
63template <class ForwardIterator1, class ForwardIterator2>
Marshall Clowee0161e2018-01-15 19:26:05 +000064 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000065 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
66 ForwardIterator2 first2, ForwardIterator2 last2);
67
68template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clowee0161e2018-01-15 19:26:05 +000069 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000070 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
71 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
72
73template <class ForwardIterator>
Marshall Clowee0161e2018-01-15 19:26:05 +000074 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000075 adjacent_find(ForwardIterator first, ForwardIterator last);
76
77template <class ForwardIterator, class BinaryPredicate>
Marshall Clowee0161e2018-01-15 19:26:05 +000078 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000079 adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
80
81template <class InputIterator, class T>
Marshall Clow3c0558f2018-01-15 19:40:34 +000082 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000083 count(InputIterator first, InputIterator last, const T& value);
84
85template <class InputIterator, class Predicate>
Marshall Clow3c0558f2018-01-15 19:40:34 +000086 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000087 count_if(InputIterator first, InputIterator last, Predicate pred);
88
89template <class InputIterator1, class InputIterator2>
Marshall Clow30bf3022018-01-16 02:04:10 +000090 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000091 mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
92
Marshall Clow96b42b22013-05-09 21:14:23 +000093template <class InputIterator1, class InputIterator2>
Marshall Clow30bf3022018-01-16 02:04:10 +000094 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Aditya Kumar3a0179a2016-08-25 11:52:38 +000095 mismatch(InputIterator1 first1, InputIterator1 last1,
Marshall Clow96b42b22013-05-09 21:14:23 +000096 InputIterator2 first2, InputIterator2 last2); // **C++14**
97
Howard Hinnantc51e1022010-05-11 19:42:16 +000098template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow30bf3022018-01-16 02:04:10 +000099 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000100 mismatch(InputIterator1 first1, InputIterator1 last1,
101 InputIterator2 first2, BinaryPredicate pred);
102
Marshall Clow96b42b22013-05-09 21:14:23 +0000103template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow30bf3022018-01-16 02:04:10 +0000104 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
Marshall Clow96b42b22013-05-09 21:14:23 +0000105 mismatch(InputIterator1 first1, InputIterator1 last1,
106 InputIterator2 first2, InputIterator2 last2,
107 BinaryPredicate pred); // **C++14**
108
Howard Hinnantc51e1022010-05-11 19:42:16 +0000109template <class InputIterator1, class InputIterator2>
Marshall Clow30bf3022018-01-16 02:04:10 +0000110 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000111 equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
112
Marshall Clow96b42b22013-05-09 21:14:23 +0000113template <class InputIterator1, class InputIterator2>
Marshall Clow30bf3022018-01-16 02:04:10 +0000114 constexpr bool // constexpr in C++20
Aditya Kumar3a0179a2016-08-25 11:52:38 +0000115 equal(InputIterator1 first1, InputIterator1 last1,
Marshall Clow96b42b22013-05-09 21:14:23 +0000116 InputIterator2 first2, InputIterator2 last2); // **C++14**
117
Howard Hinnantc51e1022010-05-11 19:42:16 +0000118template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow30bf3022018-01-16 02:04:10 +0000119 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000120 equal(InputIterator1 first1, InputIterator1 last1,
121 InputIterator2 first2, BinaryPredicate pred);
122
Marshall Clow96b42b22013-05-09 21:14:23 +0000123template <class InputIterator1, class InputIterator2, class BinaryPredicate>
Marshall Clow30bf3022018-01-16 02:04:10 +0000124 constexpr bool // constexpr in C++20
Marshall Clow96b42b22013-05-09 21:14:23 +0000125 equal(InputIterator1 first1, InputIterator1 last1,
126 InputIterator2 first2, InputIterator2 last2,
127 BinaryPredicate pred); // **C++14**
128
Howard Hinnantc51e1022010-05-11 19:42:16 +0000129template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow96d050a2018-01-15 16:16:32 +0000130 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000131 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
132 ForwardIterator2 first2);
133
Marshall Clow96b42b22013-05-09 21:14:23 +0000134template<class ForwardIterator1, class ForwardIterator2>
Marshall Clow96d050a2018-01-15 16:16:32 +0000135 constexpr bool // constexpr in C++20
Marshall Clow96b42b22013-05-09 21:14:23 +0000136 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
137 ForwardIterator2 first2, ForwardIterator2 last2); // **C++14**
138
Howard Hinnantc51e1022010-05-11 19:42:16 +0000139template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow96d050a2018-01-15 16:16:32 +0000140 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000141 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
142 ForwardIterator2 first2, BinaryPredicate pred);
143
Marshall Clow96b42b22013-05-09 21:14:23 +0000144template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow96d050a2018-01-15 16:16:32 +0000145 constexpr bool // constexpr in C++20
Marshall Clow96b42b22013-05-09 21:14:23 +0000146 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
147 ForwardIterator2 first2, ForwardIterator2 last2,
148 BinaryPredicate pred); // **C++14**
149
Howard Hinnantc51e1022010-05-11 19:42:16 +0000150template <class ForwardIterator1, class ForwardIterator2>
Marshall Clow323fc5b2018-01-16 15:48:27 +0000151 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000152 search(ForwardIterator1 first1, ForwardIterator1 last1,
153 ForwardIterator2 first2, ForwardIterator2 last2);
154
155template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
Marshall Clow323fc5b2018-01-16 15:48:27 +0000156 constexpr ForwardIterator1 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000157 search(ForwardIterator1 first1, ForwardIterator1 last1,
158 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
159
160template <class ForwardIterator, class Size, class T>
Marshall Clow323fc5b2018-01-16 15:48:27 +0000161 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000162 search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
163
164template <class ForwardIterator, class Size, class T, class BinaryPredicate>
Marshall Clow323fc5b2018-01-16 15:48:27 +0000165 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000166 search_n(ForwardIterator first, ForwardIterator last,
167 Size count, const T& value, BinaryPredicate pred);
168
169template <class InputIterator, class OutputIterator>
Louis Dionne65b433b2019-11-06 12:02:41 +0000170 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000171 copy(InputIterator first, InputIterator last, OutputIterator result);
172
173template<class InputIterator, class OutputIterator, class Predicate>
Louis Dionne65b433b2019-11-06 12:02:41 +0000174 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000175 copy_if(InputIterator first, InputIterator last,
176 OutputIterator result, Predicate pred);
177
178template<class InputIterator, class Size, class OutputIterator>
Louis Dionne65b433b2019-11-06 12:02:41 +0000179 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000180 copy_n(InputIterator first, Size n, OutputIterator result);
181
182template <class BidirectionalIterator1, class BidirectionalIterator2>
Louis Dionne65b433b2019-11-06 12:02:41 +0000183 constexpr BidirectionalIterator2 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000184 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
185 BidirectionalIterator2 result);
186
187template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500188 constexpr ForwardIterator2 // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000189 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
190
191template <class ForwardIterator1, class ForwardIterator2>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500192 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000193 iter_swap(ForwardIterator1 a, ForwardIterator2 b);
194
195template <class InputIterator, class OutputIterator, class UnaryOperation>
Marshall Clow31427c62018-01-19 17:45:39 +0000196 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000197 transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
198
199template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
Marshall Clow31427c62018-01-19 17:45:39 +0000200 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000201 transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
202 OutputIterator result, BinaryOperation binary_op);
203
204template <class ForwardIterator, class T>
Marshall Clow01bbbd22018-01-19 18:07:29 +0000205 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000206 replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
207
208template <class ForwardIterator, class Predicate, class T>
Marshall Clow01bbbd22018-01-19 18:07:29 +0000209 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000210 replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
211
212template <class InputIterator, class OutputIterator, class T>
Marshall Clow01bbbd22018-01-19 18:07:29 +0000213 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000214 replace_copy(InputIterator first, InputIterator last, OutputIterator result,
215 const T& old_value, const T& new_value);
216
217template <class InputIterator, class OutputIterator, class Predicate, class T>
Marshall Clow01bbbd22018-01-19 18:07:29 +0000218 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000219 replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
220
221template <class ForwardIterator, class T>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +0000222 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000223 fill(ForwardIterator first, ForwardIterator last, const T& value);
224
225template <class OutputIterator, class Size, class T>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +0000226 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000227 fill_n(OutputIterator first, Size n, const T& value);
228
229template <class ForwardIterator, class Generator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +0000230 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000231 generate(ForwardIterator first, ForwardIterator last, Generator gen);
232
233template <class OutputIterator, class Size, class Generator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +0000234 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000235 generate_n(OutputIterator first, Size n, Generator gen);
236
237template <class ForwardIterator, class T>
Marshall Clow7c0fbd82018-01-22 21:43:04 +0000238 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000239 remove(ForwardIterator first, ForwardIterator last, const T& value);
240
241template <class ForwardIterator, class Predicate>
Marshall Clow7c0fbd82018-01-22 21:43:04 +0000242 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000243 remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
244
245template <class InputIterator, class OutputIterator, class T>
Marshall Clow7c0fbd82018-01-22 21:43:04 +0000246 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000247 remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
248
249template <class InputIterator, class OutputIterator, class Predicate>
Marshall Clow7c0fbd82018-01-22 21:43:04 +0000250 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000251 remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
252
253template <class ForwardIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500254 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000255 unique(ForwardIterator first, ForwardIterator last);
256
257template <class ForwardIterator, class BinaryPredicate>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500258 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000259 unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
260
261template <class InputIterator, class OutputIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500262 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000263 unique_copy(InputIterator first, InputIterator last, OutputIterator result);
264
265template <class InputIterator, class OutputIterator, class BinaryPredicate>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500266 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000267 unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
268
269template <class BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -0500270 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000271 reverse(BidirectionalIterator first, BidirectionalIterator last);
272
273template <class BidirectionalIterator, class OutputIterator>
Marshall Clow7c0fbd82018-01-22 21:43:04 +0000274 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000275 reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
276
277template <class ForwardIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500278 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000279 rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
280
281template <class ForwardIterator, class OutputIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500282 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000283 rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
284
285template <class RandomAccessIterator>
286 void
Marshall Clowfac06e52017-03-23 13:43:37 +0000287 random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000288
289template <class RandomAccessIterator, class RandomNumberGenerator>
290 void
Marshall Clow83f35392014-03-03 06:14:19 +0000291 random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
Marshall Clowfac06e52017-03-23 13:43:37 +0000292 RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000293
Eric Fiselier1208fcd2016-08-28 22:14:37 +0000294template<class PopulationIterator, class SampleIterator,
295 class Distance, class UniformRandomBitGenerator>
296 SampleIterator sample(PopulationIterator first, PopulationIterator last,
297 SampleIterator out, Distance n,
298 UniformRandomBitGenerator&& g); // C++17
299
Howard Hinnant578ac0f2010-05-26 17:49:34 +0000300template<class RandomAccessIterator, class UniformRandomNumberGenerator>
301 void shuffle(RandomAccessIterator first, RandomAccessIterator last,
Howard Hinnanta5e71782010-11-18 01:47:02 +0000302 UniformRandomNumberGenerator&& g);
Howard Hinnant578ac0f2010-05-26 17:49:34 +0000303
Arthur O'Dwyercea050d2020-12-26 01:39:03 -0500304template<class ForwardIterator>
305 constexpr ForwardIterator
306 shift_left(ForwardIterator first, ForwardIterator last,
307 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
308
309template<class ForwardIterator>
310 constexpr ForwardIterator
311 shift_right(ForwardIterator first, ForwardIterator last,
312 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
313
Howard Hinnantc51e1022010-05-11 19:42:16 +0000314template <class InputIterator, class Predicate>
Marshall Clow96d050a2018-01-15 16:16:32 +0000315 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000316 is_partitioned(InputIterator first, InputIterator last, Predicate pred);
317
318template <class ForwardIterator, class Predicate>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -0500319 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000320 partition(ForwardIterator first, ForwardIterator last, Predicate pred);
321
322template <class InputIterator, class OutputIterator1,
323 class OutputIterator2, class Predicate>
Marshall Clow5492c8a2018-01-22 20:44:33 +0000324 constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000325 partition_copy(InputIterator first, InputIterator last,
326 OutputIterator1 out_true, OutputIterator2 out_false,
327 Predicate pred);
328
329template <class ForwardIterator, class Predicate>
330 ForwardIterator
331 stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
332
333template<class ForwardIterator, class Predicate>
Marshall Clowe00916c2018-01-16 02:34:41 +0000334 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000335 partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
336
337template <class ForwardIterator>
Marshall Clow96d050a2018-01-15 16:16:32 +0000338 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000339 is_sorted(ForwardIterator first, ForwardIterator last);
340
341template <class ForwardIterator, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500342 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000343 is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
344
345template<class ForwardIterator>
Marshall Clow3c0558f2018-01-15 19:40:34 +0000346 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000347 is_sorted_until(ForwardIterator first, ForwardIterator last);
348
349template <class ForwardIterator, class Compare>
Marshall Clow3c0558f2018-01-15 19:40:34 +0000350 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000351 is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
352
353template <class RandomAccessIterator>
Arthur O'Dwyer1bb0f672020-12-20 15:21:42 -0500354 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000355 sort(RandomAccessIterator first, RandomAccessIterator last);
356
357template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer1bb0f672020-12-20 15:21:42 -0500358 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000359 sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
360
361template <class RandomAccessIterator>
362 void
363 stable_sort(RandomAccessIterator first, RandomAccessIterator last);
364
365template <class RandomAccessIterator, class Compare>
366 void
367 stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
368
369template <class RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500370 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000371 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
372
373template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500374 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000375 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
376
377template <class InputIterator, class RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500378 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000379 partial_sort_copy(InputIterator first, InputIterator last,
380 RandomAccessIterator result_first, RandomAccessIterator result_last);
381
382template <class InputIterator, class RandomAccessIterator, class Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500383 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000384 partial_sort_copy(InputIterator first, InputIterator last,
385 RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
386
387template <class RandomAccessIterator>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -0800388 void
Howard Hinnantc51e1022010-05-11 19:42:16 +0000389 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
390
391template <class RandomAccessIterator, class Compare>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -0800392 void
Howard Hinnantc51e1022010-05-11 19:42:16 +0000393 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
394
395template <class ForwardIterator, class T>
Marshall Clowe00916c2018-01-16 02:34:41 +0000396 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000397 lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
398
399template <class ForwardIterator, class T, class Compare>
Marshall Clowe00916c2018-01-16 02:34:41 +0000400 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000401 lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
402
403template <class ForwardIterator, class T>
Marshall Clowe00916c2018-01-16 02:34:41 +0000404 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000405 upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
406
407template <class ForwardIterator, class T, class Compare>
Marshall Clowe00916c2018-01-16 02:34:41 +0000408 constexpr ForwardIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000409 upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
410
411template <class ForwardIterator, class T>
Marshall Clowe00916c2018-01-16 02:34:41 +0000412 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000413 equal_range(ForwardIterator first, ForwardIterator last, const T& value);
414
415template <class ForwardIterator, class T, class Compare>
Marshall Clowe00916c2018-01-16 02:34:41 +0000416 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000417 equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
418
419template <class ForwardIterator, class T>
Marshall Clowe00916c2018-01-16 02:34:41 +0000420 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000421 binary_search(ForwardIterator first, ForwardIterator last, const T& value);
422
423template <class ForwardIterator, class T, class Compare>
Marshall Clowc0b7f972018-01-22 23:10:40 +0000424 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000425 binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
426
427template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500428 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000429 merge(InputIterator1 first1, InputIterator1 last1,
430 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
431
432template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500433 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000434 merge(InputIterator1 first1, InputIterator1 last1,
435 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
436
437template <class BidirectionalIterator>
438 void
439 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
440
441template <class BidirectionalIterator, class Compare>
442 void
443 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
444
445template <class InputIterator1, class InputIterator2>
Marshall Clowc0b7f972018-01-22 23:10:40 +0000446 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000447 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
448
449template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clowc0b7f972018-01-22 23:10:40 +0000450 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000451 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
452
453template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500454 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000455 set_union(InputIterator1 first1, InputIterator1 last1,
456 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
457
458template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500459 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000460 set_union(InputIterator1 first1, InputIterator1 last1,
461 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
462
463template <class InputIterator1, class InputIterator2, class OutputIterator>
Marshall Clowc0b7f972018-01-22 23:10:40 +0000464 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000465 set_intersection(InputIterator1 first1, InputIterator1 last1,
466 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
467
468template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Marshall Clowc0b7f972018-01-22 23:10:40 +0000469 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000470 set_intersection(InputIterator1 first1, InputIterator1 last1,
471 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
472
473template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500474 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000475 set_difference(InputIterator1 first1, InputIterator1 last1,
476 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
477
478template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500479 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000480 set_difference(InputIterator1 first1, InputIterator1 last1,
481 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
482
483template <class InputIterator1, class InputIterator2, class OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500484 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000485 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
486 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
487
488template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -0500489 constexpr OutputIterator // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000490 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
491 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
492
493template <class RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500494 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000495 push_heap(RandomAccessIterator first, RandomAccessIterator last);
496
497template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500498 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000499 push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
500
501template <class RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500502 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000503 pop_heap(RandomAccessIterator first, RandomAccessIterator last);
504
505template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500506 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000507 pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
508
509template <class RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500510 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000511 make_heap(RandomAccessIterator first, RandomAccessIterator last);
512
513template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500514 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000515 make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
516
517template <class RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500518 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000519 sort_heap(RandomAccessIterator first, RandomAccessIterator last);
520
521template <class RandomAccessIterator, class Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -0500522 constexpr void // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000523 sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
524
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000525template <class RandomAccessIterator>
Marshall Clow96d050a2018-01-15 16:16:32 +0000526 constexpr bool // constexpr in C++20
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000527 is_heap(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000528
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000529template <class RandomAccessIterator, class Compare>
Marshall Clow96d050a2018-01-15 16:16:32 +0000530 constexpr bool // constexpr in C++20
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000531 is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000532
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000533template <class RandomAccessIterator>
Marshall Clow96d050a2018-01-15 16:16:32 +0000534 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000535 is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000536
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000537template <class RandomAccessIterator, class Compare>
Marshall Clow96d050a2018-01-15 16:16:32 +0000538 constexpr RandomAccessIterator // constexpr in C++20
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000539 is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000540
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000541template <class ForwardIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500542 constexpr ForwardIterator // constexpr in C++14
543 min_element(ForwardIterator first, ForwardIterator last);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000544
545template <class ForwardIterator, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500546 constexpr ForwardIterator // constexpr in C++14
547 min_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000548
Howard Hinnantc51e1022010-05-11 19:42:16 +0000549template <class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500550 constexpr const T& // constexpr in C++14
551 min(const T& a, const T& b);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000552
553template <class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500554 constexpr const T& // constexpr in C++14
555 min(const T& a, const T& b, Compare comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000556
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000557template<class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500558 constexpr T // constexpr in C++14
559 min(initializer_list<T> t);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000560
561template<class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500562 constexpr T // constexpr in C++14
563 min(initializer_list<T> t, Compare comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000564
Marshall Clow3e18d0e2016-03-07 22:43:49 +0000565template<class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500566 constexpr const T& clamp(const T& v, const T& lo, const T& hi); // C++17
Marshall Clow3e18d0e2016-03-07 22:43:49 +0000567
568template<class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500569 constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17
Marshall Clow3e18d0e2016-03-07 22:43:49 +0000570
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000571template <class ForwardIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500572 constexpr ForwardIterator // constexpr in C++14
573 max_element(ForwardIterator first, ForwardIterator last);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000574
575template <class ForwardIterator, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500576 constexpr ForwardIterator // constexpr in C++14
577 max_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000578
Howard Hinnantc51e1022010-05-11 19:42:16 +0000579template <class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500580 constexpr const T& // constexpr in C++14
581 max(const T& a, const T& b);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000582
583template <class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500584 constexpr const T& // constexpr in C++14
585 max(const T& a, const T& b, Compare comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000586
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000587template<class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500588 constexpr T // constexpr in C++14
589 max(initializer_list<T> t);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000590
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000591template<class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500592 constexpr T // constexpr in C++14
593 max(initializer_list<T> t, Compare comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000594
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000595template<class ForwardIterator>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500596 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
597 minmax_element(ForwardIterator first, ForwardIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000598
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000599template<class ForwardIterator, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500600 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
601 minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000602
603template<class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500604 constexpr pair<const T&, const T&> // constexpr in C++14
605 minmax(const T& a, const T& b);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000606
607template<class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500608 constexpr pair<const T&, const T&> // constexpr in C++14
609 minmax(const T& a, const T& b, Compare comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000610
611template<class T>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500612 constexpr pair<T, T> // constexpr in C++14
613 minmax(initializer_list<T> t);
Howard Hinnantb120e7a2010-08-21 20:10:01 +0000614
615template<class T, class Compare>
Arthur O'Dwyer20353a72020-12-02 20:02:18 -0500616 constexpr pair<T, T> // constexpr in C++14
617 minmax(initializer_list<T> t, Compare comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000618
619template <class InputIterator1, class InputIterator2>
Marshall Clow5492c8a2018-01-22 20:44:33 +0000620 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000621 lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
622
623template <class InputIterator1, class InputIterator2, class Compare>
Marshall Clow5492c8a2018-01-22 20:44:33 +0000624 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000625 lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
626 InputIterator2 first2, InputIterator2 last2, Compare comp);
627
628template <class BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -0500629 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000630 next_permutation(BidirectionalIterator first, BidirectionalIterator last);
631
632template <class BidirectionalIterator, class Compare>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -0500633 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000634 next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
635
636template <class BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -0500637 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000638 prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
639
640template <class BidirectionalIterator, class Compare>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -0500641 constexpr bool // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000642 prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
643
644} // std
645
646*/
647
648#include <__config>
649#include <initializer_list>
650#include <type_traits>
651#include <cstring>
Eric Fiselier6bfed252016-04-21 23:38:59 +0000652#include <utility> // needed to provide swap_ranges.
Howard Hinnantc51e1022010-05-11 19:42:16 +0000653#include <memory>
Marshall Clowa40686b2018-01-08 19:18:00 +0000654#include <functional>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000655#include <iterator>
Howard Hinnant60e5cf42012-07-26 17:09:09 +0000656#include <cstddef>
Marshall Clowbf32ec92018-08-17 16:07:48 +0000657#include <bit>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000658#include <version>
Howard Hinnantea382952013-08-14 18:00:20 +0000659
Eric Fiselier14b6de92014-08-10 23:53:08 +0000660#include <__debug>
661
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000662#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000663#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000664#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000665
Eric Fiselierf4433a32017-05-31 22:07:49 +0000666_LIBCPP_PUSH_MACROS
667#include <__undef_macros>
668
669
Howard Hinnantc51e1022010-05-11 19:42:16 +0000670_LIBCPP_BEGIN_NAMESPACE_STD
671
Marshall Clowe9dca072014-02-19 16:51:35 +0000672// I'd like to replace these with _VSTD::equal_to<void>, but can't because:
673// * That only works with C++14 and later, and
674// * We haven't included <functional> here.
Howard Hinnantc51e1022010-05-11 19:42:16 +0000675template <class _T1, class _T2 = _T1>
676struct __equal_to
677{
Marshall Clow1f695172018-07-14 04:15:19 +0000678 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
679 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
680 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
681 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000682};
683
684template <class _T1>
685struct __equal_to<_T1, _T1>
686{
Marshall Clowe9dca072014-02-19 16:51:35 +0000687 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
688 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000689};
690
691template <class _T1>
692struct __equal_to<const _T1, _T1>
693{
Marshall Clowe9dca072014-02-19 16:51:35 +0000694 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
695 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000696};
697
698template <class _T1>
699struct __equal_to<_T1, const _T1>
700{
Marshall Clowe9dca072014-02-19 16:51:35 +0000701 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
702 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000703};
704
705template <class _T1, class _T2 = _T1>
706struct __less
707{
Aditya Kumar3a0179a2016-08-25 11:52:38 +0000708 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clowe9dca072014-02-19 16:51:35 +0000709 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
710
711 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
712 bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
713
714 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
715 bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
716
717 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
718 bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000719};
720
721template <class _T1>
722struct __less<_T1, _T1>
723{
Marshall Clowe9dca072014-02-19 16:51:35 +0000724 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
725 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000726};
727
728template <class _T1>
729struct __less<const _T1, _T1>
730{
Marshall Clowe9dca072014-02-19 16:51:35 +0000731 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
732 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000733};
734
735template <class _T1>
736struct __less<_T1, const _T1>
737{
Marshall Clowe9dca072014-02-19 16:51:35 +0000738 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
739 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000740};
741
742template <class _Predicate>
Marshall Clow738d1042017-08-28 23:16:13 +0000743class __invert // invert the sense of a comparison
Howard Hinnantc51e1022010-05-11 19:42:16 +0000744{
745private:
746 _Predicate __p_;
747public:
Marshall Clow738d1042017-08-28 23:16:13 +0000748 _LIBCPP_INLINE_VISIBILITY __invert() {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000749
750 _LIBCPP_INLINE_VISIBILITY
Marshall Clow738d1042017-08-28 23:16:13 +0000751 explicit __invert(_Predicate __p) : __p_(__p) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000752
753 template <class _T1>
754 _LIBCPP_INLINE_VISIBILITY
755 bool operator()(const _T1& __x) {return !__p_(__x);}
756
757 template <class _T1, class _T2>
758 _LIBCPP_INLINE_VISIBILITY
Marshall Clow738d1042017-08-28 23:16:13 +0000759 bool operator()(const _T1& __x, const _T2& __y) {return __p_(__y, __x);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000760};
761
Louis Dionnedda14512018-12-17 16:04:39 +0000762// Perform division by two quickly for positive integers (llvm.org/PR39129)
763
764template <typename _Integral>
765_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
766typename enable_if
767<
768 is_integral<_Integral>::value,
769 _Integral
770>::type
771__half_positive(_Integral __value)
772{
773 return static_cast<_Integral>(static_cast<typename make_unsigned<_Integral>::type>(__value) / 2);
774}
775
776template <typename _Tp>
777_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
778typename enable_if
779<
780 !is_integral<_Tp>::value,
781 _Tp
782>::type
783__half_positive(_Tp __value)
784{
785 return __value / 2;
786}
787
Howard Hinnant6148a9b2013-08-23 20:10:18 +0000788#ifdef _LIBCPP_DEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000789
790template <class _Compare>
791struct __debug_less
792{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +0000793 _Compare &__comp_;
794 _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000795 __debug_less(_Compare& __c) : __comp_(__c) {}
Eric Fiselier32adec82016-07-19 23:27:18 +0000796
Howard Hinnantc51e1022010-05-11 19:42:16 +0000797 template <class _Tp, class _Up>
Thomas Andersona371b732019-04-19 00:52:54 +0000798 _LIBCPP_CONSTEXPR_AFTER_CXX17
Thomas Andersond364ec92019-04-15 17:02:15 +0000799 bool operator()(const _Tp& __x, const _Up& __y)
800 {
801 bool __r = __comp_(__x, __y);
802 if (__r)
803 __do_compare_assert(0, __y, __x);
804 return __r;
805 }
806
807 template <class _Tp, class _Up>
Eric Fiselier7ceab7b2019-04-12 05:18:19 +0000808 _LIBCPP_CONSTEXPR_AFTER_CXX17
Eric Fiselier6dfe5232019-03-08 22:58:59 +0000809 bool operator()(_Tp& __x, _Up& __y)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000810 {
811 bool __r = __comp_(__x, __y);
812 if (__r)
Eric Fiselier32adec82016-07-19 23:27:18 +0000813 __do_compare_assert(0, __y, __x);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000814 return __r;
815 }
Eric Fiselier32adec82016-07-19 23:27:18 +0000816
817 template <class _LHS, class _RHS>
Eric Fiselier7ceab7b2019-04-12 05:18:19 +0000818 _LIBCPP_CONSTEXPR_AFTER_CXX17
Eric Fiselier32adec82016-07-19 23:27:18 +0000819 inline _LIBCPP_INLINE_VISIBILITY
820 decltype((void)_VSTD::declval<_Compare&>()(
Eric Fiselier6dfe5232019-03-08 22:58:59 +0000821 _VSTD::declval<_LHS &>(), _VSTD::declval<_RHS &>()))
822 __do_compare_assert(int, _LHS & __l, _RHS & __r) {
Eric Fiselier32adec82016-07-19 23:27:18 +0000823 _LIBCPP_ASSERT(!__comp_(__l, __r),
824 "Comparator does not induce a strict weak ordering");
825 }
826
827 template <class _LHS, class _RHS>
Eric Fiselier7ceab7b2019-04-12 05:18:19 +0000828 _LIBCPP_CONSTEXPR_AFTER_CXX17
Eric Fiselier32adec82016-07-19 23:27:18 +0000829 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6dfe5232019-03-08 22:58:59 +0000830 void __do_compare_assert(long, _LHS &, _RHS &) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000831};
832
Eric Fiselier6dfe5232019-03-08 22:58:59 +0000833#endif // _LIBCPP_DEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000834
Eric Fiselier7ceab7b2019-04-12 05:18:19 +0000835template <class _Comp>
836struct __comp_ref_type {
837 // Pass the comparator by lvalue reference. Or in debug mode, using a
838 // debugging wrapper that stores a reference.
839#ifndef _LIBCPP_DEBUG
840 typedef typename add_lvalue_reference<_Comp>::type type;
841#else
842 typedef __debug_less<_Comp> type;
843#endif
844};
845
Howard Hinnantc51e1022010-05-11 19:42:16 +0000846// all_of
847
848template <class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +0000849_LIBCPP_NODISCARD_EXT inline
850_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000851bool
852all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
853{
854 for (; __first != __last; ++__first)
855 if (!__pred(*__first))
856 return false;
857 return true;
858}
859
860// any_of
861
862template <class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +0000863_LIBCPP_NODISCARD_EXT inline
864_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000865bool
866any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
867{
868 for (; __first != __last; ++__first)
869 if (__pred(*__first))
870 return true;
871 return false;
872}
873
874// none_of
875
876template <class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +0000877_LIBCPP_NODISCARD_EXT inline
878_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000879bool
880none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
881{
882 for (; __first != __last; ++__first)
883 if (__pred(*__first))
884 return false;
885 return true;
886}
887
888// for_each
889
890template <class _InputIterator, class _Function>
Marshall Clow5492c8a2018-01-22 20:44:33 +0000891inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000892_Function
893for_each(_InputIterator __first, _InputIterator __last, _Function __f)
894{
895 for (; __first != __last; ++__first)
896 __f(*__first);
Marshall Clow78dbe462016-11-14 18:22:19 +0000897 return __f;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000898}
899
Marshall Clowc588fd62017-05-25 13:40:57 +0000900#if _LIBCPP_STD_VER > 14
Marshall Clowde0169c2017-05-25 02:29:54 +0000901// for_each_n
902
903template <class _InputIterator, class _Size, class _Function>
Marshall Clow5492c8a2018-01-22 20:44:33 +0000904inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clowde0169c2017-05-25 02:29:54 +0000905_InputIterator
906for_each_n(_InputIterator __first, _Size __orig_n, _Function __f)
907{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -0500908 typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
Marshall Clowde0169c2017-05-25 02:29:54 +0000909 _IntegralSize __n = __orig_n;
910 while (__n > 0)
911 {
912 __f(*__first);
913 ++__first;
914 --__n;
915 }
916 return __first;
917}
Marshall Clowc588fd62017-05-25 13:40:57 +0000918#endif
Marshall Clowde0169c2017-05-25 02:29:54 +0000919
Howard Hinnantc51e1022010-05-11 19:42:16 +0000920// find
921
922template <class _InputIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +0000923_LIBCPP_NODISCARD_EXT inline
924_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000925_InputIterator
Howard Hinnantbf074022011-10-22 20:59:45 +0000926find(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000927{
928 for (; __first != __last; ++__first)
Howard Hinnantbf074022011-10-22 20:59:45 +0000929 if (*__first == __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000930 break;
931 return __first;
932}
933
934// find_if
935
936template <class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +0000937_LIBCPP_NODISCARD_EXT inline
938_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000939_InputIterator
940find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
941{
942 for (; __first != __last; ++__first)
943 if (__pred(*__first))
944 break;
945 return __first;
946}
947
948// find_if_not
949
950template<class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +0000951_LIBCPP_NODISCARD_EXT inline
952_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000953_InputIterator
954find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred)
955{
956 for (; __first != __last; ++__first)
957 if (!__pred(*__first))
958 break;
959 return __first;
960}
961
962// find_end
963
964template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
Marshall Clowee0161e2018-01-15 19:26:05 +0000965_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator1
Howard Hinnantc51e1022010-05-11 19:42:16 +0000966__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
967 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
968 forward_iterator_tag, forward_iterator_tag)
969{
970 // modeled after search algorithm
971 _ForwardIterator1 __r = __last1; // __last1 is the "default" answer
972 if (__first2 == __last2)
973 return __r;
974 while (true)
975 {
976 while (true)
977 {
978 if (__first1 == __last1) // if source exhausted return last correct answer
979 return __r; // (or __last1 if never found)
980 if (__pred(*__first1, *__first2))
981 break;
982 ++__first1;
983 }
984 // *__first1 matches *__first2, now match elements after here
985 _ForwardIterator1 __m1 = __first1;
986 _ForwardIterator2 __m2 = __first2;
987 while (true)
988 {
989 if (++__m2 == __last2)
990 { // Pattern exhaused, record answer and search for another one
991 __r = __first1;
992 ++__first1;
993 break;
994 }
995 if (++__m1 == __last1) // Source exhausted, return last answer
996 return __r;
997 if (!__pred(*__m1, *__m2)) // mismatch, restart with a new __first
998 {
999 ++__first1;
1000 break;
1001 } // else there is a match, check next elements
1002 }
1003 }
1004}
1005
1006template <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2>
Marshall Clowee0161e2018-01-15 19:26:05 +00001007_LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator1
Howard Hinnantc51e1022010-05-11 19:42:16 +00001008__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
1009 _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred,
1010 bidirectional_iterator_tag, bidirectional_iterator_tag)
1011{
1012 // modeled after search algorithm (in reverse)
1013 if (__first2 == __last2)
1014 return __last1; // Everything matches an empty sequence
1015 _BidirectionalIterator1 __l1 = __last1;
1016 _BidirectionalIterator2 __l2 = __last2;
1017 --__l2;
1018 while (true)
1019 {
1020 // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks
1021 while (true)
1022 {
1023 if (__first1 == __l1) // return __last1 if no element matches *__first2
1024 return __last1;
1025 if (__pred(*--__l1, *__l2))
1026 break;
1027 }
1028 // *__l1 matches *__l2, now match elements before here
1029 _BidirectionalIterator1 __m1 = __l1;
1030 _BidirectionalIterator2 __m2 = __l2;
1031 while (true)
1032 {
1033 if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern)
1034 return __m1;
1035 if (__m1 == __first1) // Otherwise if source exhaused, pattern not found
1036 return __last1;
1037 if (!__pred(*--__m1, *--__m2)) // if there is a mismatch, restart with a new __l1
1038 {
1039 break;
1040 } // else there is a match, check next elements
1041 }
1042 }
1043}
1044
1045template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
Marshall Clowedfd25a2014-06-10 18:51:55 +00001046_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator1
Howard Hinnantc51e1022010-05-11 19:42:16 +00001047__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
1048 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
1049 random_access_iterator_tag, random_access_iterator_tag)
1050{
1051 // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
1052 typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2;
1053 if (__len2 == 0)
1054 return __last1;
1055 typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1;
1056 if (__len1 < __len2)
1057 return __last1;
1058 const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here
1059 _RandomAccessIterator1 __l1 = __last1;
1060 _RandomAccessIterator2 __l2 = __last2;
1061 --__l2;
1062 while (true)
1063 {
1064 while (true)
1065 {
1066 if (__s == __l1)
1067 return __last1;
1068 if (__pred(*--__l1, *__l2))
1069 break;
1070 }
1071 _RandomAccessIterator1 __m1 = __l1;
1072 _RandomAccessIterator2 __m2 = __l2;
1073 while (true)
1074 {
1075 if (__m2 == __first2)
1076 return __m1;
1077 // no need to check range on __m1 because __s guarantees we have enough source
1078 if (!__pred(*--__m1, *--__m2))
1079 {
1080 break;
1081 }
1082 }
1083 }
1084}
1085
1086template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001087_LIBCPP_NODISCARD_EXT inline
1088_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001089_ForwardIterator1
1090find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1091 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1092{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001093 return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001094 (__first1, __last1, __first2, __last2, __pred,
1095 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1096 typename iterator_traits<_ForwardIterator2>::iterator_category());
1097}
1098
1099template <class _ForwardIterator1, class _ForwardIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001100_LIBCPP_NODISCARD_EXT inline
1101_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001102_ForwardIterator1
1103find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1104 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1105{
1106 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1107 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001108 return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001109}
1110
1111// find_first_of
1112
1113template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
Marshall Clowedfd25a2014-06-10 18:51:55 +00001114_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator1
1115__find_first_of_ce(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001116 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1117{
1118 for (; __first1 != __last1; ++__first1)
1119 for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
1120 if (__pred(*__first1, *__j))
1121 return __first1;
1122 return __last1;
1123}
1124
Marshall Clowedfd25a2014-06-10 18:51:55 +00001125
1126template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001127_LIBCPP_NODISCARD_EXT inline
1128_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clowedfd25a2014-06-10 18:51:55 +00001129_ForwardIterator1
1130find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1131 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1132{
1133 return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred);
1134}
1135
Howard Hinnantc51e1022010-05-11 19:42:16 +00001136template <class _ForwardIterator1, class _ForwardIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001137_LIBCPP_NODISCARD_EXT inline
1138_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001139_ForwardIterator1
1140find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1141 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1142{
1143 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1144 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
Marshall Clowedfd25a2014-06-10 18:51:55 +00001145 return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001146}
1147
1148// adjacent_find
1149
1150template <class _ForwardIterator, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001151_LIBCPP_NODISCARD_EXT inline
1152_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001153_ForwardIterator
1154adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
1155{
1156 if (__first != __last)
1157 {
1158 _ForwardIterator __i = __first;
1159 while (++__i != __last)
1160 {
1161 if (__pred(*__first, *__i))
1162 return __first;
1163 __first = __i;
1164 }
1165 }
1166 return __last;
1167}
1168
1169template <class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00001170_LIBCPP_NODISCARD_EXT inline
1171_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001172_ForwardIterator
1173adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
1174{
1175 typedef typename iterator_traits<_ForwardIterator>::value_type __v;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001176 return _VSTD::adjacent_find(__first, __last, __equal_to<__v>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001177}
1178
1179// count
1180
1181template <class _InputIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00001182_LIBCPP_NODISCARD_EXT inline
1183_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001184typename iterator_traits<_InputIterator>::difference_type
Howard Hinnantbf074022011-10-22 20:59:45 +00001185count(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001186{
1187 typename iterator_traits<_InputIterator>::difference_type __r(0);
1188 for (; __first != __last; ++__first)
Howard Hinnantbf074022011-10-22 20:59:45 +00001189 if (*__first == __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001190 ++__r;
1191 return __r;
1192}
1193
1194// count_if
1195
1196template <class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001197_LIBCPP_NODISCARD_EXT inline
1198_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001199typename iterator_traits<_InputIterator>::difference_type
1200count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
1201{
1202 typename iterator_traits<_InputIterator>::difference_type __r(0);
1203 for (; __first != __last; ++__first)
1204 if (__pred(*__first))
1205 ++__r;
1206 return __r;
1207}
1208
1209// mismatch
1210
1211template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001212_LIBCPP_NODISCARD_EXT inline
1213_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001214pair<_InputIterator1, _InputIterator2>
1215mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
1216 _InputIterator2 __first2, _BinaryPredicate __pred)
1217{
Marshall Clow2932e512014-09-16 20:40:05 +00001218 for (; __first1 != __last1; ++__first1, (void) ++__first2)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001219 if (!__pred(*__first1, *__first2))
1220 break;
1221 return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
1222}
1223
1224template <class _InputIterator1, class _InputIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001225_LIBCPP_NODISCARD_EXT inline
1226_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001227pair<_InputIterator1, _InputIterator2>
1228mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
1229{
1230 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1231 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001232 return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001233}
1234
Marshall Clow96b42b22013-05-09 21:14:23 +00001235#if _LIBCPP_STD_VER > 11
1236template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001237_LIBCPP_NODISCARD_EXT inline
1238_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001239pair<_InputIterator1, _InputIterator2>
1240mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
1241 _InputIterator2 __first2, _InputIterator2 __last2,
1242 _BinaryPredicate __pred)
1243{
Marshall Clow2932e512014-09-16 20:40:05 +00001244 for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
Marshall Clow96b42b22013-05-09 21:14:23 +00001245 if (!__pred(*__first1, *__first2))
1246 break;
1247 return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
1248}
1249
1250template <class _InputIterator1, class _InputIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001251_LIBCPP_NODISCARD_EXT inline
1252_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001253pair<_InputIterator1, _InputIterator2>
1254mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
1255 _InputIterator2 __first2, _InputIterator2 __last2)
1256{
1257 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1258 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
1259 return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
1260}
1261#endif
1262
Howard Hinnantc51e1022010-05-11 19:42:16 +00001263// equal
1264
1265template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001266_LIBCPP_NODISCARD_EXT inline
1267_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001268bool
1269equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred)
1270{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001271 for (; __first1 != __last1; ++__first1, (void) ++__first2)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001272 if (!__pred(*__first1, *__first2))
1273 return false;
1274 return true;
1275}
1276
1277template <class _InputIterator1, class _InputIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001278_LIBCPP_NODISCARD_EXT inline
1279_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001280bool
1281equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
1282{
1283 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1284 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001285 return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001286}
1287
Marshall Clow96b42b22013-05-09 21:14:23 +00001288#if _LIBCPP_STD_VER > 11
1289template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
Marshall Clow30bf3022018-01-16 02:04:10 +00001290inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001291bool
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001292__equal(_InputIterator1 __first1, _InputIterator1 __last1,
Marshall Clow96b42b22013-05-09 21:14:23 +00001293 _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred,
1294 input_iterator_tag, input_iterator_tag )
1295{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001296 for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
Marshall Clow96b42b22013-05-09 21:14:23 +00001297 if (!__pred(*__first1, *__first2))
1298 return false;
1299 return __first1 == __last1 && __first2 == __last2;
1300}
1301
1302template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
Marshall Clow30bf3022018-01-16 02:04:10 +00001303inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001304bool
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001305__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
1306 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
Marshall Clow96b42b22013-05-09 21:14:23 +00001307 random_access_iterator_tag, random_access_iterator_tag )
1308{
1309 if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
1310 return false;
1311 return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2,
1312 typename add_lvalue_reference<_BinaryPredicate>::type>
1313 (__first1, __last1, __first2, __pred );
1314}
1315
1316template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001317_LIBCPP_NODISCARD_EXT inline
1318_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001319bool
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001320equal(_InputIterator1 __first1, _InputIterator1 __last1,
Marshall Clow96b42b22013-05-09 21:14:23 +00001321 _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred )
1322{
1323 return _VSTD::__equal<typename add_lvalue_reference<_BinaryPredicate>::type>
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001324 (__first1, __last1, __first2, __last2, __pred,
Marshall Clow96b42b22013-05-09 21:14:23 +00001325 typename iterator_traits<_InputIterator1>::iterator_category(),
1326 typename iterator_traits<_InputIterator2>::iterator_category());
1327}
1328
1329template <class _InputIterator1, class _InputIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001330_LIBCPP_NODISCARD_EXT inline
1331_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001332bool
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001333equal(_InputIterator1 __first1, _InputIterator1 __last1,
Marshall Clow96b42b22013-05-09 21:14:23 +00001334 _InputIterator2 __first2, _InputIterator2 __last2)
1335{
1336 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1337 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
1338 return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(),
1339 typename iterator_traits<_InputIterator1>::iterator_category(),
1340 typename iterator_traits<_InputIterator2>::iterator_category());
1341}
1342#endif
1343
Howard Hinnantc51e1022010-05-11 19:42:16 +00001344// is_permutation
1345
1346template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001347_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00001348is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1349 _ForwardIterator2 __first2, _BinaryPredicate __pred)
1350{
Marshall Clow96d050a2018-01-15 16:16:32 +00001351// shorten sequences as much as possible by lopping of any equal prefix
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001352 for (; __first1 != __last1; ++__first1, (void) ++__first2)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001353 if (!__pred(*__first1, *__first2))
Marshall Clow96d050a2018-01-15 16:16:32 +00001354 break;
1355 if (__first1 == __last1)
1356 return true;
1357
1358// __first1 != __last1 && *__first1 != *__first2
Howard Hinnantc51e1022010-05-11 19:42:16 +00001359 typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001360 _D1 __l1 = _VSTD::distance(__first1, __last1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001361 if (__l1 == _D1(1))
1362 return false;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001363 _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001364 // For each element in [f1, l1) see if there are the same number of
1365 // equal elements in [f2, l2)
1366 for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
1367 {
Marshall Clow96d050a2018-01-15 16:16:32 +00001368 // Have we already counted the number of *__i in [f1, l1)?
Peter Collingbournea5b451b2018-01-26 21:23:27 +00001369 _ForwardIterator1 __match = __first1;
1370 for (; __match != __i; ++__match)
1371 if (__pred(*__match, *__i))
1372 break;
1373 if (__match == __i) {
Howard Hinnantc51e1022010-05-11 19:42:16 +00001374 // Count number of *__i in [f2, l2)
1375 _D1 __c2 = 0;
1376 for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
1377 if (__pred(*__i, *__j))
1378 ++__c2;
1379 if (__c2 == 0)
1380 return false;
1381 // Count number of *__i in [__i, l1) (we can start with 1)
1382 _D1 __c1 = 1;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001383 for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001384 if (__pred(*__i, *__j))
1385 ++__c1;
1386 if (__c1 != __c2)
1387 return false;
1388 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001389 }
1390 return true;
1391}
1392
1393template<class _ForwardIterator1, class _ForwardIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001394_LIBCPP_NODISCARD_EXT inline
1395_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001396bool
1397is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1398 _ForwardIterator2 __first2)
1399{
1400 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1401 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001402 return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001403}
1404
Marshall Clow96b42b22013-05-09 21:14:23 +00001405#if _LIBCPP_STD_VER > 11
1406template<class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
Marshall Clow96d050a2018-01-15 16:16:32 +00001407_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Marshall Clow96b42b22013-05-09 21:14:23 +00001408__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001409 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
Marshall Clow96b42b22013-05-09 21:14:23 +00001410 _BinaryPredicate __pred,
1411 forward_iterator_tag, forward_iterator_tag )
1412{
Marshall Clow96d050a2018-01-15 16:16:32 +00001413// shorten sequences as much as possible by lopping of any equal prefix
Eric Fiselier14673892014-10-27 20:26:25 +00001414 for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
Marshall Clow96b42b22013-05-09 21:14:23 +00001415 if (!__pred(*__first1, *__first2))
Marshall Clow96d050a2018-01-15 16:16:32 +00001416 break;
1417 if (__first1 == __last1)
Marshall Clow01bbbd22018-01-19 18:07:29 +00001418 return __first2 == __last2;
Marshall Clow96d050a2018-01-15 16:16:32 +00001419 else if (__first2 == __last2)
Marshall Clow01bbbd22018-01-19 18:07:29 +00001420 return false;
Marshall Clow96d050a2018-01-15 16:16:32 +00001421
Marshall Clow96b42b22013-05-09 21:14:23 +00001422 typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
1423 _D1 __l1 = _VSTD::distance(__first1, __last1);
1424
1425 typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2;
Marshall Clow42b967c2013-05-10 00:16:10 +00001426 _D2 __l2 = _VSTD::distance(__first2, __last2);
Marshall Clow96b42b22013-05-09 21:14:23 +00001427 if (__l1 != __l2)
1428 return false;
1429
1430 // For each element in [f1, l1) see if there are the same number of
1431 // equal elements in [f2, l2)
1432 for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
1433 {
Marshall Clow96d050a2018-01-15 16:16:32 +00001434 // Have we already counted the number of *__i in [f1, l1)?
Peter Collingbournea5b451b2018-01-26 21:23:27 +00001435 _ForwardIterator1 __match = __first1;
1436 for (; __match != __i; ++__match)
1437 if (__pred(*__match, *__i))
1438 break;
1439 if (__match == __i) {
Marshall Clow96b42b22013-05-09 21:14:23 +00001440 // Count number of *__i in [f2, l2)
1441 _D1 __c2 = 0;
1442 for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
1443 if (__pred(*__i, *__j))
1444 ++__c2;
1445 if (__c2 == 0)
1446 return false;
1447 // Count number of *__i in [__i, l1) (we can start with 1)
1448 _D1 __c1 = 1;
1449 for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
1450 if (__pred(*__i, *__j))
1451 ++__c1;
1452 if (__c1 != __c2)
1453 return false;
1454 }
Marshall Clow96b42b22013-05-09 21:14:23 +00001455 }
1456 return true;
1457}
1458
1459template<class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
Marshall Clow96d050a2018-01-15 16:16:32 +00001460_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Marshall Clow96b42b22013-05-09 21:14:23 +00001461__is_permutation(_RandomAccessIterator1 __first1, _RandomAccessIterator2 __last1,
Aditya Kumar3a0179a2016-08-25 11:52:38 +00001462 _RandomAccessIterator1 __first2, _RandomAccessIterator2 __last2,
Marshall Clow96b42b22013-05-09 21:14:23 +00001463 _BinaryPredicate __pred,
1464 random_access_iterator_tag, random_access_iterator_tag )
1465{
1466 if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
1467 return false;
1468 return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2,
1469 typename add_lvalue_reference<_BinaryPredicate>::type>
1470 (__first1, __last1, __first2, __pred );
1471}
1472
1473template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001474_LIBCPP_NODISCARD_EXT inline
1475_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001476bool
1477is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1478 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
1479 _BinaryPredicate __pred )
1480{
1481 return _VSTD::__is_permutation<typename add_lvalue_reference<_BinaryPredicate>::type>
1482 (__first1, __last1, __first2, __last2, __pred,
1483 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1484 typename iterator_traits<_ForwardIterator2>::iterator_category());
1485}
1486
1487template<class _ForwardIterator1, class _ForwardIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001488_LIBCPP_NODISCARD_EXT inline
1489_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clow96b42b22013-05-09 21:14:23 +00001490bool
1491is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1492 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1493{
1494 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1495 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
1496 return _VSTD::__is_permutation(__first1, __last1, __first2, __last2,
1497 __equal_to<__v1, __v2>(),
1498 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1499 typename iterator_traits<_ForwardIterator2>::iterator_category());
1500}
1501#endif
1502
Howard Hinnantc51e1022010-05-11 19:42:16 +00001503// search
Marshall Clowa40686b2018-01-08 19:18:00 +00001504// __search is in <functional>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001505
1506template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001507_LIBCPP_NODISCARD_EXT inline
1508_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001509_ForwardIterator1
1510search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1511 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1512{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001513 return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001514 (__first1, __last1, __first2, __last2, __pred,
Marshall Clowaf8be6c2016-03-08 15:12:52 +00001515 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1516 typename iterator_traits<_ForwardIterator2>::iterator_category())
1517 .first;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001518}
1519
1520template <class _ForwardIterator1, class _ForwardIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00001521_LIBCPP_NODISCARD_EXT inline
1522_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001523_ForwardIterator1
1524search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1525 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1526{
Marshall Clowaf8be6c2016-03-08 15:12:52 +00001527 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1528 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001529 return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001530}
1531
Marshall Clowa40686b2018-01-08 19:18:00 +00001532
1533#if _LIBCPP_STD_VER > 14
1534template <class _ForwardIterator, class _Searcher>
Nico Weber471b10a2019-04-03 18:13:08 +00001535_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Marshall Clowa40686b2018-01-08 19:18:00 +00001536_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
1537{ return __s(__f, __l).first; }
1538#endif
1539
Howard Hinnantc51e1022010-05-11 19:42:16 +00001540// search_n
1541
1542template <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
Marshall Clow323fc5b2018-01-16 15:48:27 +00001543_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00001544__search_n(_ForwardIterator __first, _ForwardIterator __last,
Howard Hinnantbf074022011-10-22 20:59:45 +00001545 _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001546{
1547 if (__count <= 0)
1548 return __first;
1549 while (true)
1550 {
Howard Hinnantbf074022011-10-22 20:59:45 +00001551 // Find first element in sequence that matchs __value_, with a mininum of loop checks
Howard Hinnantc51e1022010-05-11 19:42:16 +00001552 while (true)
1553 {
Howard Hinnantbf074022011-10-22 20:59:45 +00001554 if (__first == __last) // return __last if no element matches __value_
Howard Hinnantc51e1022010-05-11 19:42:16 +00001555 return __last;
Howard Hinnantbf074022011-10-22 20:59:45 +00001556 if (__pred(*__first, __value_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001557 break;
1558 ++__first;
1559 }
Howard Hinnantbf074022011-10-22 20:59:45 +00001560 // *__first matches __value_, now match elements after here
Howard Hinnantc51e1022010-05-11 19:42:16 +00001561 _ForwardIterator __m = __first;
1562 _Size __c(0);
1563 while (true)
1564 {
1565 if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
1566 return __first;
1567 if (++__m == __last) // Otherwise if source exhaused, pattern not found
1568 return __last;
Howard Hinnantbf074022011-10-22 20:59:45 +00001569 if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
Howard Hinnantc51e1022010-05-11 19:42:16 +00001570 {
1571 __first = __m;
1572 ++__first;
1573 break;
1574 } // else there is a match, check next elements
1575 }
1576 }
1577}
1578
1579template <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
Marshall Clow323fc5b2018-01-16 15:48:27 +00001580_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00001581__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last,
Howard Hinnantbf074022011-10-22 20:59:45 +00001582 _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001583{
1584 if (__count <= 0)
1585 return __first;
1586 _Size __len = static_cast<_Size>(__last - __first);
1587 if (__len < __count)
1588 return __last;
1589 const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here
1590 while (true)
1591 {
Howard Hinnantbf074022011-10-22 20:59:45 +00001592 // Find first element in sequence that matchs __value_, with a mininum of loop checks
Howard Hinnantc51e1022010-05-11 19:42:16 +00001593 while (true)
1594 {
Howard Hinnantbede4c32013-04-04 15:40:48 +00001595 if (__first >= __s) // return __last if no element matches __value_
Howard Hinnantc51e1022010-05-11 19:42:16 +00001596 return __last;
Howard Hinnantbf074022011-10-22 20:59:45 +00001597 if (__pred(*__first, __value_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001598 break;
1599 ++__first;
1600 }
Howard Hinnantbf074022011-10-22 20:59:45 +00001601 // *__first matches __value_, now match elements after here
Howard Hinnantc51e1022010-05-11 19:42:16 +00001602 _RandomAccessIterator __m = __first;
1603 _Size __c(0);
1604 while (true)
1605 {
1606 if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
1607 return __first;
1608 ++__m; // no need to check range on __m because __s guarantees we have enough source
Howard Hinnantbf074022011-10-22 20:59:45 +00001609 if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
Howard Hinnantc51e1022010-05-11 19:42:16 +00001610 {
1611 __first = __m;
1612 ++__first;
1613 break;
1614 } // else there is a match, check next elements
1615 }
1616 }
1617}
1618
1619template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00001620_LIBCPP_NODISCARD_EXT inline
1621_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001622_ForwardIterator
1623search_n(_ForwardIterator __first, _ForwardIterator __last,
Howard Hinnantbf074022011-10-22 20:59:45 +00001624 _Size __count, const _Tp& __value_, _BinaryPredicate __pred)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001625{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001626 return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -05001627 (__first, __last, _VSTD::__convert_to_integral(__count), __value_, __pred,
Eric Fiselier97ec07d2015-02-10 16:46:42 +00001628 typename iterator_traits<_ForwardIterator>::iterator_category());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001629}
1630
1631template <class _ForwardIterator, class _Size, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00001632_LIBCPP_NODISCARD_EXT inline
1633_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001634_ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00001635search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001636{
1637 typedef typename iterator_traits<_ForwardIterator>::value_type __v;
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -05001638 return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count),
Eric Fiselier97ec07d2015-02-10 16:46:42 +00001639 __value_, __equal_to<__v, _Tp>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001640}
1641
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001642// __unwrap_iter
Howard Hinnantc51e1022010-05-11 19:42:16 +00001643
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001644// The job of __unwrap_iter is to lower iterators-that-are-tantamount-to-pointers
1645// (such as vector<T>::iterator) into pointers, to reduce the number of template
1646// instantiations and to enable pointer-based optimizations e.g. in std::copy.
1647// In debug mode, we don't do this.
1648
1649template <class _Iter, bool = __is_cpp17_contiguous_iterator<_Iter>::value>
1650struct __unwrap_iter_impl {
1651 static _LIBCPP_CONSTEXPR _Iter
1652 __apply(_Iter __i) _NOEXCEPT {
1653 return __i;
1654 }
1655};
Howard Hinnantc51e1022010-05-11 19:42:16 +00001656
Howard Hinnant8ea98242013-08-23 17:37:05 +00001657#if _LIBCPP_DEBUG_LEVEL < 2
1658
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001659template <class _Iter>
1660struct __unwrap_iter_impl<_Iter, true> {
1661 static _LIBCPP_CONSTEXPR decltype(_VSTD::__to_address(declval<_Iter>()))
1662 __apply(_Iter __i) _NOEXCEPT {
1663 return _VSTD::__to_address(__i);
1664 }
1665};
Eric Fiselier38badb82016-12-28 05:35:32 +00001666
Howard Hinnant8ea98242013-08-23 17:37:05 +00001667#endif // _LIBCPP_DEBUG_LEVEL < 2
1668
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001669template<class _Iter, class _Impl = __unwrap_iter_impl<_Iter> >
1670inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1671decltype(_Impl::__apply(_VSTD::declval<_Iter>()))
1672__unwrap_iter(_Iter __i) _NOEXCEPT
1673{
1674 return _Impl::__apply(__i);
1675}
1676
1677// copy
1678
Howard Hinnantc51e1022010-05-11 19:42:16 +00001679template <class _InputIterator, class _OutputIterator>
Louis Dionne65b433b2019-11-06 12:02:41 +00001680inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001681_OutputIterator
Louis Dionne65b433b2019-11-06 12:02:41 +00001682__copy_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001683{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001684 for (; __first != __last; ++__first, (void) ++__result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001685 *__result = *__first;
1686 return __result;
1687}
1688
Louis Dionne65b433b2019-11-06 12:02:41 +00001689template <class _InputIterator, class _OutputIterator>
1690inline _LIBCPP_INLINE_VISIBILITY
1691_OutputIterator
1692__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1693{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001694 return _VSTD::__copy_constexpr(__first, __last, __result);
Louis Dionne65b433b2019-11-06 12:02:41 +00001695}
1696
Howard Hinnantc51e1022010-05-11 19:42:16 +00001697template <class _Tp, class _Up>
1698inline _LIBCPP_INLINE_VISIBILITY
1699typename enable_if
1700<
1701 is_same<typename remove_const<_Tp>::type, _Up>::value &&
Howard Hinnanta9a897e2010-11-19 22:17:28 +00001702 is_trivially_copy_assignable<_Up>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001703 _Up*
1704>::type
1705__copy(_Tp* __first, _Tp* __last, _Up* __result)
1706{
1707 const size_t __n = static_cast<size_t>(__last - __first);
Marshall Clowc3ef9622015-06-02 13:52:16 +00001708 if (__n > 0)
1709 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001710 return __result + __n;
1711}
1712
1713template <class _InputIterator, class _OutputIterator>
Arthur O'Dwyer14606d12020-11-23 12:44:41 -05001714inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001715_OutputIterator
1716copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1717{
Louis Dionne65b433b2019-11-06 12:02:41 +00001718 if (__libcpp_is_constant_evaluated()) {
1719 return _VSTD::__copy_constexpr(
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001720 _VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
Louis Dionne65b433b2019-11-06 12:02:41 +00001721 } else {
1722 return _VSTD::__copy(
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001723 _VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
Louis Dionne65b433b2019-11-06 12:02:41 +00001724 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001725}
1726
1727// copy_backward
1728
Howard Hinnant7f229bc2013-02-06 21:03:39 +00001729template <class _BidirectionalIterator, class _OutputIterator>
Louis Dionne65b433b2019-11-06 12:02:41 +00001730inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1731_OutputIterator
1732__copy_backward_constexpr(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
1733{
1734 while (__first != __last)
1735 *--__result = *--__last;
1736 return __result;
1737}
1738
1739template <class _BidirectionalIterator, class _OutputIterator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001740inline _LIBCPP_INLINE_VISIBILITY
1741_OutputIterator
Howard Hinnant7f229bc2013-02-06 21:03:39 +00001742__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001743{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001744 return _VSTD::__copy_backward_constexpr(__first, __last, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001745}
1746
1747template <class _Tp, class _Up>
1748inline _LIBCPP_INLINE_VISIBILITY
1749typename enable_if
1750<
1751 is_same<typename remove_const<_Tp>::type, _Up>::value &&
Howard Hinnanta9a897e2010-11-19 22:17:28 +00001752 is_trivially_copy_assignable<_Up>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001753 _Up*
1754>::type
1755__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
1756{
1757 const size_t __n = static_cast<size_t>(__last - __first);
Marshall Clowc3ef9622015-06-02 13:52:16 +00001758 if (__n > 0)
1759 {
1760 __result -= __n;
1761 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
1762 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001763 return __result;
1764}
1765
1766template <class _BidirectionalIterator1, class _BidirectionalIterator2>
Arthur O'Dwyer14606d12020-11-23 12:44:41 -05001767inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001768_BidirectionalIterator2
1769copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
1770 _BidirectionalIterator2 __result)
1771{
Louis Dionne65b433b2019-11-06 12:02:41 +00001772 if (__libcpp_is_constant_evaluated()) {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001773 return _VSTD::__copy_backward_constexpr(_VSTD::__unwrap_iter(__first),
1774 _VSTD::__unwrap_iter(__last),
1775 _VSTD::__unwrap_iter(__result));
Louis Dionne65b433b2019-11-06 12:02:41 +00001776 } else {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001777 return _VSTD::__copy_backward(_VSTD::__unwrap_iter(__first),
1778 _VSTD::__unwrap_iter(__last),
1779 _VSTD::__unwrap_iter(__result));
Louis Dionne65b433b2019-11-06 12:02:41 +00001780 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001781}
1782
1783// copy_if
1784
1785template<class _InputIterator, class _OutputIterator, class _Predicate>
Louis Dionne65b433b2019-11-06 12:02:41 +00001786inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001787_OutputIterator
1788copy_if(_InputIterator __first, _InputIterator __last,
1789 _OutputIterator __result, _Predicate __pred)
1790{
1791 for (; __first != __last; ++__first)
1792 {
1793 if (__pred(*__first))
1794 {
1795 *__result = *__first;
1796 ++__result;
1797 }
1798 }
1799 return __result;
1800}
1801
1802// copy_n
1803
1804template<class _InputIterator, class _Size, class _OutputIterator>
Arthur O'Dwyer14606d12020-11-23 12:44:41 -05001805inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001806typename enable_if
1807<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001808 __is_cpp17_input_iterator<_InputIterator>::value &&
1809 !__is_cpp17_random_access_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001810 _OutputIterator
1811>::type
Eric Fiselier97ec07d2015-02-10 16:46:42 +00001812copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001813{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -05001814 typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
Eric Fiselier97ec07d2015-02-10 16:46:42 +00001815 _IntegralSize __n = __orig_n;
Howard Hinnantcbc5dc02011-02-27 20:55:39 +00001816 if (__n > 0)
1817 {
Howard Hinnantc51e1022010-05-11 19:42:16 +00001818 *__result = *__first;
Howard Hinnantcbc5dc02011-02-27 20:55:39 +00001819 ++__result;
1820 for (--__n; __n > 0; --__n)
1821 {
1822 ++__first;
1823 *__result = *__first;
1824 ++__result;
1825 }
1826 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001827 return __result;
1828}
1829
1830template<class _InputIterator, class _Size, class _OutputIterator>
Arthur O'Dwyer14606d12020-11-23 12:44:41 -05001831inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001832typename enable_if
1833<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001834 __is_cpp17_random_access_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001835 _OutputIterator
1836>::type
Eric Fiselier97ec07d2015-02-10 16:46:42 +00001837copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001838{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -05001839 typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
Eric Fiselier97ec07d2015-02-10 16:46:42 +00001840 _IntegralSize __n = __orig_n;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001841 return _VSTD::copy(__first, __first + __n, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001842}
1843
1844// move
1845
zoecarverd0279de2020-09-14 18:11:08 -04001846// __move_constexpr exists so that __move doesn't call itself when delegating to the constexpr
1847// version of __move.
Howard Hinnantc51e1022010-05-11 19:42:16 +00001848template <class _InputIterator, class _OutputIterator>
zoecarverd0279de2020-09-14 18:11:08 -04001849inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001850_OutputIterator
zoecarverd0279de2020-09-14 18:11:08 -04001851__move_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001852{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001853 for (; __first != __last; ++__first, (void) ++__result)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001854 *__result = _VSTD::move(*__first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001855 return __result;
1856}
1857
zoecarverd0279de2020-09-14 18:11:08 -04001858template <class _InputIterator, class _OutputIterator>
1859inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1860_OutputIterator
1861__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1862{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001863 return _VSTD::__move_constexpr(__first, __last, __result);
zoecarverd0279de2020-09-14 18:11:08 -04001864}
1865
Howard Hinnantc51e1022010-05-11 19:42:16 +00001866template <class _Tp, class _Up>
zoecarverd0279de2020-09-14 18:11:08 -04001867inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001868typename enable_if
1869<
1870 is_same<typename remove_const<_Tp>::type, _Up>::value &&
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001871 is_trivially_move_assignable<_Up>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001872 _Up*
1873>::type
1874__move(_Tp* __first, _Tp* __last, _Up* __result)
1875{
zoecarverd0279de2020-09-14 18:11:08 -04001876 if (__libcpp_is_constant_evaluated())
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001877 return _VSTD::__move_constexpr(__first, __last, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001878 const size_t __n = static_cast<size_t>(__last - __first);
Marshall Clowc3ef9622015-06-02 13:52:16 +00001879 if (__n > 0)
1880 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001881 return __result + __n;
1882}
1883
1884template <class _InputIterator, class _OutputIterator>
zoecarverd0279de2020-09-14 18:11:08 -04001885inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001886_OutputIterator
1887move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1888{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001889 return _VSTD::__move(_VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001890}
1891
1892// move_backward
1893
zoecarverd0279de2020-09-14 18:11:08 -04001894// __move_backward_constexpr exists so that __move_backward doesn't call itself when delegating to
1895// the constexpr version of __move_backward.
Howard Hinnantc51e1022010-05-11 19:42:16 +00001896template <class _InputIterator, class _OutputIterator>
zoecarverd0279de2020-09-14 18:11:08 -04001897inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001898_OutputIterator
zoecarverd0279de2020-09-14 18:11:08 -04001899__move_backward_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001900{
1901 while (__first != __last)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001902 *--__result = _VSTD::move(*--__last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001903 return __result;
1904}
1905
zoecarverd0279de2020-09-14 18:11:08 -04001906template <class _InputIterator, class _OutputIterator>
1907inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1908_OutputIterator
1909__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1910{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001911 return _VSTD::__move_backward_constexpr(__first, __last, __result);
zoecarverd0279de2020-09-14 18:11:08 -04001912}
1913
Howard Hinnantc51e1022010-05-11 19:42:16 +00001914template <class _Tp, class _Up>
zoecarverd0279de2020-09-14 18:11:08 -04001915inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001916typename enable_if
1917<
1918 is_same<typename remove_const<_Tp>::type, _Up>::value &&
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001919 is_trivially_move_assignable<_Up>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001920 _Up*
1921>::type
1922__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
1923{
zoecarverd0279de2020-09-14 18:11:08 -04001924 if (__libcpp_is_constant_evaluated())
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001925 return _VSTD::__move_backward_constexpr(__first, __last, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001926 const size_t __n = static_cast<size_t>(__last - __first);
Marshall Clowc3ef9622015-06-02 13:52:16 +00001927 if (__n > 0)
1928 {
1929 __result -= __n;
1930 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
1931 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001932 return __result;
1933}
1934
1935template <class _BidirectionalIterator1, class _BidirectionalIterator2>
zoecarverd0279de2020-09-14 18:11:08 -04001936inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001937_BidirectionalIterator2
1938move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
1939 _BidirectionalIterator2 __result)
1940{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05001941 return _VSTD::__move_backward(_VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001942}
1943
1944// iter_swap
1945
Howard Hinnantdbfd4b42011-05-27 15:04:19 +00001946// moved to <type_traits> for better swap / noexcept support
Howard Hinnantc51e1022010-05-11 19:42:16 +00001947
1948// transform
1949
1950template <class _InputIterator, class _OutputIterator, class _UnaryOperation>
Marshall Clow31427c62018-01-19 17:45:39 +00001951inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001952_OutputIterator
1953transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
1954{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001955 for (; __first != __last; ++__first, (void) ++__result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001956 *__result = __op(*__first);
1957 return __result;
1958}
1959
1960template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
Marshall Clow31427c62018-01-19 17:45:39 +00001961inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001962_OutputIterator
1963transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
1964 _OutputIterator __result, _BinaryOperation __binary_op)
1965{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00001966 for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001967 *__result = __binary_op(*__first1, *__first2);
1968 return __result;
1969}
1970
1971// replace
1972
1973template <class _ForwardIterator, class _Tp>
Marshall Clow01bbbd22018-01-19 18:07:29 +00001974inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001975void
1976replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value)
1977{
1978 for (; __first != __last; ++__first)
1979 if (*__first == __old_value)
1980 *__first = __new_value;
1981}
1982
1983// replace_if
1984
1985template <class _ForwardIterator, class _Predicate, class _Tp>
Marshall Clow01bbbd22018-01-19 18:07:29 +00001986inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001987void
1988replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
1989{
1990 for (; __first != __last; ++__first)
1991 if (__pred(*__first))
1992 *__first = __new_value;
1993}
1994
1995// replace_copy
1996
1997template <class _InputIterator, class _OutputIterator, class _Tp>
Marshall Clow01bbbd22018-01-19 18:07:29 +00001998inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00001999_OutputIterator
2000replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
2001 const _Tp& __old_value, const _Tp& __new_value)
2002{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00002003 for (; __first != __last; ++__first, (void) ++__result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002004 if (*__first == __old_value)
2005 *__result = __new_value;
2006 else
2007 *__result = *__first;
2008 return __result;
2009}
2010
2011// replace_copy_if
2012
2013template <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
Marshall Clow01bbbd22018-01-19 18:07:29 +00002014inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002015_OutputIterator
2016replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
2017 _Predicate __pred, const _Tp& __new_value)
2018{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00002019 for (; __first != __last; ++__first, (void) ++__result)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002020 if (__pred(*__first))
2021 *__result = __new_value;
2022 else
2023 *__result = *__first;
2024 return __result;
2025}
2026
2027// fill_n
2028
2029template <class _OutputIterator, class _Size, class _Tp>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002030inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002031_OutputIterator
Howard Hinnant0ad1c122013-08-01 17:29:28 +00002032__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002033{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00002034 for (; __n > 0; ++__first, (void) --__n)
Howard Hinnantbf074022011-10-22 20:59:45 +00002035 *__first = __value_;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002036 return __first;
2037}
2038
Howard Hinnantc51e1022010-05-11 19:42:16 +00002039template <class _OutputIterator, class _Size, class _Tp>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002040inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002041_OutputIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00002042fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002043{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -05002044 return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value_);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002045}
2046
2047// fill
2048
2049template <class _ForwardIterator, class _Tp>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002050inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002051void
Howard Hinnantbf074022011-10-22 20:59:45 +00002052__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002053{
2054 for (; __first != __last; ++__first)
Howard Hinnantbf074022011-10-22 20:59:45 +00002055 *__first = __value_;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002056}
2057
2058template <class _RandomAccessIterator, class _Tp>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002059inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002060void
Howard Hinnantbf074022011-10-22 20:59:45 +00002061__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002062{
Howard Hinnantbf074022011-10-22 20:59:45 +00002063 _VSTD::fill_n(__first, __last - __first, __value_);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002064}
2065
2066template <class _ForwardIterator, class _Tp>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002067inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002068void
Howard Hinnantbf074022011-10-22 20:59:45 +00002069fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002070{
Howard Hinnantbf074022011-10-22 20:59:45 +00002071 _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002072}
2073
2074// generate
2075
2076template <class _ForwardIterator, class _Generator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002077inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002078void
2079generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
2080{
2081 for (; __first != __last; ++__first)
2082 *__first = __gen();
2083}
2084
2085// generate_n
2086
2087template <class _OutputIterator, class _Size, class _Generator>
Nico Weber471b10a2019-04-03 18:13:08 +00002088inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002089_OutputIterator
Eric Fiselier97ec07d2015-02-10 16:46:42 +00002090generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002091{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -05002092 typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
Eric Fiselier97ec07d2015-02-10 16:46:42 +00002093 _IntegralSize __n = __orig_n;
Eric Fiseliera09a3b42014-10-27 19:28:20 +00002094 for (; __n > 0; ++__first, (void) --__n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002095 *__first = __gen();
2096 return __first;
2097}
2098
2099// remove
2100
2101template <class _ForwardIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002102_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00002103remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002104{
Howard Hinnantbf074022011-10-22 20:59:45 +00002105 __first = _VSTD::find(__first, __last, __value_);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002106 if (__first != __last)
2107 {
2108 _ForwardIterator __i = __first;
2109 while (++__i != __last)
2110 {
Howard Hinnantbf074022011-10-22 20:59:45 +00002111 if (!(*__i == __value_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00002112 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002113 *__first = _VSTD::move(*__i);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002114 ++__first;
2115 }
2116 }
2117 }
2118 return __first;
2119}
2120
2121// remove_if
2122
2123template <class _ForwardIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +00002124_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00002125remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
2126{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002127 __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002128 (__first, __last, __pred);
2129 if (__first != __last)
2130 {
2131 _ForwardIterator __i = __first;
2132 while (++__i != __last)
2133 {
2134 if (!__pred(*__i))
2135 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002136 *__first = _VSTD::move(*__i);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002137 ++__first;
2138 }
2139 }
2140 }
2141 return __first;
2142}
2143
2144// remove_copy
2145
2146template <class _InputIterator, class _OutputIterator, class _Tp>
Marshall Clow7c0fbd82018-01-22 21:43:04 +00002147inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002148_OutputIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00002149remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002150{
2151 for (; __first != __last; ++__first)
2152 {
Howard Hinnantbf074022011-10-22 20:59:45 +00002153 if (!(*__first == __value_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00002154 {
2155 *__result = *__first;
2156 ++__result;
2157 }
2158 }
2159 return __result;
2160}
2161
2162// remove_copy_if
2163
2164template <class _InputIterator, class _OutputIterator, class _Predicate>
Marshall Clow7c0fbd82018-01-22 21:43:04 +00002165inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002166_OutputIterator
2167remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
2168{
2169 for (; __first != __last; ++__first)
2170 {
2171 if (!__pred(*__first))
2172 {
2173 *__result = *__first;
2174 ++__result;
2175 }
2176 }
2177 return __result;
2178}
2179
2180// unique
2181
2182template <class _ForwardIterator, class _BinaryPredicate>
Nico Weber471b10a2019-04-03 18:13:08 +00002183_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00002184unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
2185{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002186 __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002187 (__first, __last, __pred);
2188 if (__first != __last)
2189 {
2190 // ... a a ? ...
2191 // f i
2192 _ForwardIterator __i = __first;
2193 for (++__i; ++__i != __last;)
2194 if (!__pred(*__first, *__i))
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002195 *++__first = _VSTD::move(*__i);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002196 ++__first;
2197 }
2198 return __first;
2199}
2200
2201template <class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00002202_LIBCPP_NODISCARD_EXT inline
2203_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002204_ForwardIterator
2205unique(_ForwardIterator __first, _ForwardIterator __last)
2206{
2207 typedef typename iterator_traits<_ForwardIterator>::value_type __v;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002208 return _VSTD::unique(__first, __last, __equal_to<__v>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002209}
2210
2211// unique_copy
2212
2213template <class _BinaryPredicate, class _InputIterator, class _OutputIterator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002214_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00002215__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
2216 input_iterator_tag, output_iterator_tag)
2217{
2218 if (__first != __last)
2219 {
2220 typename iterator_traits<_InputIterator>::value_type __t(*__first);
2221 *__result = __t;
2222 ++__result;
2223 while (++__first != __last)
2224 {
2225 if (!__pred(__t, *__first))
2226 {
2227 __t = *__first;
2228 *__result = __t;
2229 ++__result;
2230 }
2231 }
2232 }
2233 return __result;
2234}
2235
2236template <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002237_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00002238__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
2239 forward_iterator_tag, output_iterator_tag)
2240{
2241 if (__first != __last)
2242 {
2243 _ForwardIterator __i = __first;
2244 *__result = *__i;
2245 ++__result;
2246 while (++__first != __last)
2247 {
2248 if (!__pred(*__i, *__first))
2249 {
2250 *__result = *__first;
2251 ++__result;
2252 __i = __first;
2253 }
2254 }
2255 }
2256 return __result;
2257}
2258
2259template <class _BinaryPredicate, class _InputIterator, class _ForwardIterator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002260_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00002261__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred,
2262 input_iterator_tag, forward_iterator_tag)
2263{
2264 if (__first != __last)
2265 {
2266 *__result = *__first;
2267 while (++__first != __last)
2268 if (!__pred(*__result, *__first))
2269 *++__result = *__first;
2270 ++__result;
2271 }
2272 return __result;
2273}
2274
Howard Hinnantc51e1022010-05-11 19:42:16 +00002275template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002276inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002277_OutputIterator
2278unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
2279{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002280 return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002281 (__first, __last, __result, __pred,
2282 typename iterator_traits<_InputIterator>::iterator_category(),
2283 typename iterator_traits<_OutputIterator>::iterator_category());
2284}
2285
2286template <class _InputIterator, class _OutputIterator>
Marshall Clowe9cdc5c2018-01-20 20:14:32 +00002287inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002288_OutputIterator
2289unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
2290{
2291 typedef typename iterator_traits<_InputIterator>::value_type __v;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002292 return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002293}
2294
2295// reverse
2296
2297template <class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05002298inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002299void
2300__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
2301{
2302 while (__first != __last)
2303 {
2304 if (__first == --__last)
2305 break;
Marshall Clow2ad71042015-11-02 21:34:25 +00002306 _VSTD::iter_swap(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002307 ++__first;
2308 }
2309}
2310
2311template <class _RandomAccessIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05002312inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002313void
2314__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
2315{
2316 if (__first != __last)
2317 for (; __first < --__last; ++__first)
Marshall Clow2ad71042015-11-02 21:34:25 +00002318 _VSTD::iter_swap(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002319}
2320
2321template <class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05002322inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002323void
2324reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
2325{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002326 _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002327}
2328
2329// reverse_copy
2330
2331template <class _BidirectionalIterator, class _OutputIterator>
Marshall Clow7c0fbd82018-01-22 21:43:04 +00002332inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002333_OutputIterator
2334reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
2335{
2336 for (; __first != __last; ++__result)
2337 *__result = *--__last;
2338 return __result;
2339}
2340
2341// rotate
2342
2343template <class _ForwardIterator>
zoecarverd0279de2020-09-14 18:11:08 -04002344_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002345__rotate_left(_ForwardIterator __first, _ForwardIterator __last)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002346{
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002347 typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
2348 value_type __tmp = _VSTD::move(*__first);
2349 _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first);
2350 *__lm1 = _VSTD::move(__tmp);
2351 return __lm1;
2352}
2353
2354template <class _BidirectionalIterator>
zoecarverd0279de2020-09-14 18:11:08 -04002355_LIBCPP_CONSTEXPR_AFTER_CXX11 _BidirectionalIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002356__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
2357{
2358 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
2359 _BidirectionalIterator __lm1 = _VSTD::prev(__last);
2360 value_type __tmp = _VSTD::move(*__lm1);
2361 _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last);
2362 *__first = _VSTD::move(__tmp);
2363 return __fp1;
2364}
2365
2366template <class _ForwardIterator>
zoecarverd0279de2020-09-14 18:11:08 -04002367_LIBCPP_CONSTEXPR_AFTER_CXX14 _ForwardIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002368__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
2369{
Howard Hinnantc51e1022010-05-11 19:42:16 +00002370 _ForwardIterator __i = __middle;
2371 while (true)
2372 {
2373 swap(*__first, *__i);
2374 ++__first;
2375 if (++__i == __last)
2376 break;
2377 if (__first == __middle)
2378 __middle = __i;
2379 }
2380 _ForwardIterator __r = __first;
2381 if (__first != __middle)
2382 {
2383 __i = __middle;
2384 while (true)
2385 {
2386 swap(*__first, *__i);
2387 ++__first;
2388 if (++__i == __last)
2389 {
2390 if (__first == __middle)
2391 break;
2392 __i = __middle;
2393 }
2394 else if (__first == __middle)
2395 __middle = __i;
2396 }
2397 }
2398 return __r;
2399}
2400
2401template<typename _Integral>
2402inline _LIBCPP_INLINE_VISIBILITY
zoecarverd0279de2020-09-14 18:11:08 -04002403_LIBCPP_CONSTEXPR_AFTER_CXX14 _Integral
Marshall Clowb8bfc2c2016-07-26 14:29:45 +00002404__algo_gcd(_Integral __x, _Integral __y)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002405{
2406 do
2407 {
2408 _Integral __t = __x % __y;
2409 __x = __y;
2410 __y = __t;
2411 } while (__y);
2412 return __x;
2413}
2414
2415template<typename _RandomAccessIterator>
zoecarverd0279de2020-09-14 18:11:08 -04002416_LIBCPP_CONSTEXPR_AFTER_CXX14 _RandomAccessIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002417__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002418{
2419 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
2420 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00002421
Howard Hinnantc51e1022010-05-11 19:42:16 +00002422 const difference_type __m1 = __middle - __first;
2423 const difference_type __m2 = __last - __middle;
2424 if (__m1 == __m2)
2425 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002426 _VSTD::swap_ranges(__first, __middle, __middle);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002427 return __middle;
2428 }
Marshall Clowb8bfc2c2016-07-26 14:29:45 +00002429 const difference_type __g = _VSTD::__algo_gcd(__m1, __m2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002430 for (_RandomAccessIterator __p = __first + __g; __p != __first;)
2431 {
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002432 value_type __t(_VSTD::move(*--__p));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002433 _RandomAccessIterator __p1 = __p;
2434 _RandomAccessIterator __p2 = __p1 + __m1;
2435 do
2436 {
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002437 *__p1 = _VSTD::move(*__p2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002438 __p1 = __p2;
2439 const difference_type __d = __last - __p2;
2440 if (__m1 < __d)
2441 __p2 += __m1;
2442 else
2443 __p2 = __first + (__m1 - __d);
2444 } while (__p2 != __p);
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002445 *__p1 = _VSTD::move(__t);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002446 }
2447 return __first + __m2;
2448}
2449
2450template <class _ForwardIterator>
2451inline _LIBCPP_INLINE_VISIBILITY
zoecarverd0279de2020-09-14 18:11:08 -04002452_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002453__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
2454 _VSTD::forward_iterator_tag)
2455{
2456 typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type;
2457 if (_VSTD::is_trivially_move_assignable<value_type>::value)
2458 {
2459 if (_VSTD::next(__first) == __middle)
2460 return _VSTD::__rotate_left(__first, __last);
2461 }
2462 return _VSTD::__rotate_forward(__first, __middle, __last);
2463}
2464
2465template <class _BidirectionalIterator>
2466inline _LIBCPP_INLINE_VISIBILITY
zoecarverd0279de2020-09-14 18:11:08 -04002467_LIBCPP_CONSTEXPR_AFTER_CXX11 _BidirectionalIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002468__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
2469 _VSTD::bidirectional_iterator_tag)
2470{
2471 typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type;
2472 if (_VSTD::is_trivially_move_assignable<value_type>::value)
2473 {
2474 if (_VSTD::next(__first) == __middle)
2475 return _VSTD::__rotate_left(__first, __last);
2476 if (_VSTD::next(__middle) == __last)
2477 return _VSTD::__rotate_right(__first, __last);
2478 }
2479 return _VSTD::__rotate_forward(__first, __middle, __last);
2480}
2481
2482template <class _RandomAccessIterator>
2483inline _LIBCPP_INLINE_VISIBILITY
zoecarverd0279de2020-09-14 18:11:08 -04002484_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002485__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
2486 _VSTD::random_access_iterator_tag)
2487{
2488 typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type;
2489 if (_VSTD::is_trivially_move_assignable<value_type>::value)
2490 {
2491 if (_VSTD::next(__first) == __middle)
2492 return _VSTD::__rotate_left(__first, __last);
2493 if (_VSTD::next(__middle) == __last)
2494 return _VSTD::__rotate_right(__first, __last);
2495 return _VSTD::__rotate_gcd(__first, __middle, __last);
2496 }
2497 return _VSTD::__rotate_forward(__first, __middle, __last);
2498}
2499
2500template <class _ForwardIterator>
2501inline _LIBCPP_INLINE_VISIBILITY
zoecarverd0279de2020-09-14 18:11:08 -04002502_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00002503rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
2504{
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002505 if (__first == __middle)
2506 return __last;
2507 if (__middle == __last)
2508 return __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002509 return _VSTD::__rotate(__first, __middle, __last,
Howard Hinnant5fec4ff2012-08-03 18:01:20 +00002510 typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002511}
2512
2513// rotate_copy
2514
2515template <class _ForwardIterator, class _OutputIterator>
Nicholas-Baron7fd82722020-09-14 16:37:41 -04002516inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002517_OutputIterator
2518rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
2519{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002520 return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002521}
2522
Howard Hinnantc51e1022010-05-11 19:42:16 +00002523// min_element
2524
2525template <class _ForwardIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002526_LIBCPP_NODISCARD_EXT inline
2527_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00002528_ForwardIterator
Marshall Clow9e173072015-05-10 13:53:31 +00002529min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002530{
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002531 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
Eric Fiselierf8ecd942018-08-22 17:47:13 +00002532 "std::min_element requires a ForwardIterator");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002533 if (__first != __last)
2534 {
2535 _ForwardIterator __i = __first;
2536 while (++__i != __last)
2537 if (__comp(*__i, *__first))
2538 __first = __i;
2539 }
2540 return __first;
2541}
2542
2543template <class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00002544_LIBCPP_NODISCARD_EXT inline
2545_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00002546_ForwardIterator
2547min_element(_ForwardIterator __first, _ForwardIterator __last)
2548{
Marshall Clow9e173072015-05-10 13:53:31 +00002549 return _VSTD::min_element(__first, __last,
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002550 __less<typename iterator_traits<_ForwardIterator>::value_type>());
2551}
2552
2553// min
2554
2555template <class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002556_LIBCPP_NODISCARD_EXT inline
2557_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002558const _Tp&
2559min(const _Tp& __a, const _Tp& __b, _Compare __comp)
2560{
2561 return __comp(__b, __a) ? __b : __a;
2562}
2563
2564template <class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002565_LIBCPP_NODISCARD_EXT inline
2566_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002567const _Tp&
2568min(const _Tp& __a, const _Tp& __b)
2569{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002570 return _VSTD::min(__a, __b, __less<_Tp>());
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002571}
2572
Eric Fiselier93dd1372017-04-18 23:26:47 +00002573#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002574
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002575template<class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002576_LIBCPP_NODISCARD_EXT inline
2577_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002578_Tp
2579min(initializer_list<_Tp> __t, _Compare __comp)
2580{
Marshall Clow9e173072015-05-10 13:53:31 +00002581 return *_VSTD::min_element(__t.begin(), __t.end(), __comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002582}
2583
2584template<class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002585_LIBCPP_NODISCARD_EXT inline
2586_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002587_Tp
2588min(initializer_list<_Tp> __t)
2589{
Marshall Clow9e173072015-05-10 13:53:31 +00002590 return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002591}
2592
Eric Fiselier93dd1372017-04-18 23:26:47 +00002593#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002594
Howard Hinnantc51e1022010-05-11 19:42:16 +00002595// max_element
2596
2597template <class _ForwardIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002598_LIBCPP_NODISCARD_EXT inline
2599_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00002600_ForwardIterator
Marshall Clow9e173072015-05-10 13:53:31 +00002601max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002602{
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002603 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
Eric Fiselierf8ecd942018-08-22 17:47:13 +00002604 "std::max_element requires a ForwardIterator");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002605 if (__first != __last)
2606 {
2607 _ForwardIterator __i = __first;
2608 while (++__i != __last)
2609 if (__comp(*__first, *__i))
2610 __first = __i;
2611 }
2612 return __first;
2613}
2614
Marshall Clowe9dca072014-02-19 16:51:35 +00002615
Howard Hinnantc51e1022010-05-11 19:42:16 +00002616template <class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00002617_LIBCPP_NODISCARD_EXT inline
2618_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00002619_ForwardIterator
2620max_element(_ForwardIterator __first, _ForwardIterator __last)
2621{
Marshall Clow9e173072015-05-10 13:53:31 +00002622 return _VSTD::max_element(__first, __last,
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002623 __less<typename iterator_traits<_ForwardIterator>::value_type>());
2624}
2625
2626// max
2627
2628template <class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002629_LIBCPP_NODISCARD_EXT inline
2630_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002631const _Tp&
2632max(const _Tp& __a, const _Tp& __b, _Compare __comp)
2633{
2634 return __comp(__a, __b) ? __b : __a;
2635}
2636
2637template <class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002638_LIBCPP_NODISCARD_EXT inline
2639_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002640const _Tp&
2641max(const _Tp& __a, const _Tp& __b)
2642{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002643 return _VSTD::max(__a, __b, __less<_Tp>());
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002644}
2645
Eric Fiselier93dd1372017-04-18 23:26:47 +00002646#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002647
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002648template<class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002649_LIBCPP_NODISCARD_EXT inline
2650_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002651_Tp
2652max(initializer_list<_Tp> __t, _Compare __comp)
2653{
Marshall Clow9e173072015-05-10 13:53:31 +00002654 return *_VSTD::max_element(__t.begin(), __t.end(), __comp);
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002655}
2656
2657template<class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002658_LIBCPP_NODISCARD_EXT inline
2659_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002660_Tp
2661max(initializer_list<_Tp> __t)
2662{
Marshall Clow9e173072015-05-10 13:53:31 +00002663 return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002664}
2665
Eric Fiselier93dd1372017-04-18 23:26:47 +00002666#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002667
Marshall Clow3e18d0e2016-03-07 22:43:49 +00002668#if _LIBCPP_STD_VER > 14
2669// clamp
2670template<class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002671_LIBCPP_NODISCARD_EXT inline
2672_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Marshall Clow3e18d0e2016-03-07 22:43:49 +00002673const _Tp&
2674clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
2675{
2676 _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
2677 return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
2678
2679}
2680
2681template<class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002682_LIBCPP_NODISCARD_EXT inline
2683_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Marshall Clow3e18d0e2016-03-07 22:43:49 +00002684const _Tp&
2685clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi)
2686{
2687 return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>());
2688}
2689#endif
2690
Howard Hinnantc51e1022010-05-11 19:42:16 +00002691// minmax_element
2692
2693template <class _ForwardIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002694_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX11
Arthur O'Dwyer07b22492020-11-27 11:02:06 -05002695pair<_ForwardIterator, _ForwardIterator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002696minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
2697{
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002698 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
Eric Fiselierf8ecd942018-08-22 17:47:13 +00002699 "std::minmax_element requires a ForwardIterator");
Arthur O'Dwyer07b22492020-11-27 11:02:06 -05002700 pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002701 if (__first != __last)
2702 {
2703 if (++__first != __last)
2704 {
2705 if (__comp(*__first, *__result.first))
Howard Hinnantc51e1022010-05-11 19:42:16 +00002706 __result.first = __first;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002707 else
2708 __result.second = __first;
2709 while (++__first != __last)
2710 {
2711 _ForwardIterator __i = __first;
2712 if (++__first == __last)
2713 {
2714 if (__comp(*__i, *__result.first))
2715 __result.first = __i;
2716 else if (!__comp(*__i, *__result.second))
2717 __result.second = __i;
2718 break;
2719 }
2720 else
2721 {
2722 if (__comp(*__first, *__i))
2723 {
2724 if (__comp(*__first, *__result.first))
2725 __result.first = __first;
2726 if (!__comp(*__i, *__result.second))
2727 __result.second = __i;
2728 }
2729 else
2730 {
2731 if (__comp(*__i, *__result.first))
2732 __result.first = __i;
2733 if (!__comp(*__first, *__result.second))
2734 __result.second = __first;
2735 }
2736 }
2737 }
2738 }
2739 }
2740 return __result;
2741}
2742
2743template <class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00002744_LIBCPP_NODISCARD_EXT inline
2745_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Arthur O'Dwyer07b22492020-11-27 11:02:06 -05002746pair<_ForwardIterator, _ForwardIterator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002747minmax_element(_ForwardIterator __first, _ForwardIterator __last)
2748{
Marshall Clowe9dca072014-02-19 16:51:35 +00002749 return _VSTD::minmax_element(__first, __last,
2750 __less<typename iterator_traits<_ForwardIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002751}
2752
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002753// minmax
2754
2755template<class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002756_LIBCPP_NODISCARD_EXT inline
2757_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002758pair<const _Tp&, const _Tp&>
2759minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
2760{
2761 return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
2762 pair<const _Tp&, const _Tp&>(__a, __b);
2763}
2764
2765template<class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002766_LIBCPP_NODISCARD_EXT inline
2767_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002768pair<const _Tp&, const _Tp&>
2769minmax(const _Tp& __a, const _Tp& __b)
2770{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002771 return _VSTD::minmax(__a, __b, __less<_Tp>());
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002772}
2773
Eric Fiselier93dd1372017-04-18 23:26:47 +00002774#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002775
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002776template<class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00002777_LIBCPP_NODISCARD_EXT inline
2778_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002779pair<_Tp, _Tp>
2780minmax(initializer_list<_Tp> __t, _Compare __comp)
2781{
Marshall Clowe9dca072014-02-19 16:51:35 +00002782 typedef typename initializer_list<_Tp>::const_iterator _Iter;
2783 _Iter __first = __t.begin();
2784 _Iter __last = __t.end();
Arthur O'Dwyer07b22492020-11-27 11:02:06 -05002785 pair<_Tp, _Tp> __result(*__first, *__first);
Marshall Clowe9dca072014-02-19 16:51:35 +00002786
2787 ++__first;
2788 if (__t.size() % 2 == 0)
2789 {
2790 if (__comp(*__first, __result.first))
2791 __result.first = *__first;
2792 else
2793 __result.second = *__first;
2794 ++__first;
2795 }
Aditya Kumar3a0179a2016-08-25 11:52:38 +00002796
Marshall Clowe9dca072014-02-19 16:51:35 +00002797 while (__first != __last)
2798 {
2799 _Tp __prev = *__first++;
Marshall Clow447713a2015-02-11 15:41:34 +00002800 if (__comp(*__first, __prev)) {
2801 if ( __comp(*__first, __result.first)) __result.first = *__first;
2802 if (!__comp(__prev, __result.second)) __result.second = __prev;
Marshall Clowe9dca072014-02-19 16:51:35 +00002803 }
2804 else {
Marshall Clow447713a2015-02-11 15:41:34 +00002805 if ( __comp(__prev, __result.first)) __result.first = __prev;
2806 if (!__comp(*__first, __result.second)) __result.second = *__first;
Marshall Clowe9dca072014-02-19 16:51:35 +00002807 }
Aditya Kumar3a0179a2016-08-25 11:52:38 +00002808
Marshall Clowe9dca072014-02-19 16:51:35 +00002809 __first++;
2810 }
2811 return __result;
2812}
2813
2814template<class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00002815_LIBCPP_NODISCARD_EXT inline
2816_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clowe9dca072014-02-19 16:51:35 +00002817pair<_Tp, _Tp>
2818minmax(initializer_list<_Tp> __t)
2819{
2820 return _VSTD::minmax(__t, __less<_Tp>());
Howard Hinnantb120e7a2010-08-21 20:10:01 +00002821}
2822
Eric Fiselier93dd1372017-04-18 23:26:47 +00002823#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002824
Howard Hinnantc51e1022010-05-11 19:42:16 +00002825// random_shuffle
2826
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002827// __independent_bits_engine
2828
Howard Hinnantc834c512011-11-29 18:15:50 +00002829template <unsigned long long _Xp, size_t _Rp>
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002830struct __log2_imp
Howard Hinnantc51e1022010-05-11 19:42:16 +00002831{
Howard Hinnantc834c512011-11-29 18:15:50 +00002832 static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
2833 : __log2_imp<_Xp, _Rp - 1>::value;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002834};
2835
Howard Hinnantc834c512011-11-29 18:15:50 +00002836template <unsigned long long _Xp>
2837struct __log2_imp<_Xp, 0>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002838{
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002839 static const size_t value = 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002840};
2841
Howard Hinnantc834c512011-11-29 18:15:50 +00002842template <size_t _Rp>
2843struct __log2_imp<0, _Rp>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002844{
Howard Hinnantc834c512011-11-29 18:15:50 +00002845 static const size_t value = _Rp + 1;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002846};
2847
Eric Fiselier4638fca2017-05-31 21:20:18 +00002848template <class _UIntType, _UIntType _Xp>
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002849struct __log2
Howard Hinnantc51e1022010-05-11 19:42:16 +00002850{
Howard Hinnantc834c512011-11-29 18:15:50 +00002851 static const size_t value = __log2_imp<_Xp,
Eric Fiselier4638fca2017-05-31 21:20:18 +00002852 sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002853};
2854
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002855template<class _Engine, class _UIntType>
2856class __independent_bits_engine
Howard Hinnantc51e1022010-05-11 19:42:16 +00002857{
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002858public:
2859 // types
2860 typedef _UIntType result_type;
2861
2862private:
2863 typedef typename _Engine::result_type _Engine_result_type;
2864 typedef typename conditional
2865 <
2866 sizeof(_Engine_result_type) <= sizeof(result_type),
2867 result_type,
2868 _Engine_result_type
2869 >::type _Working_result_type;
2870
2871 _Engine& __e_;
2872 size_t __w_;
2873 size_t __w0_;
2874 size_t __n_;
2875 size_t __n0_;
2876 _Working_result_type __y0_;
2877 _Working_result_type __y1_;
2878 _Engine_result_type __mask0_;
2879 _Engine_result_type __mask1_;
2880
Eric Fiselier93dd1372017-04-18 23:26:47 +00002881#ifdef _LIBCPP_CXX03_LANG
Howard Hinnantc834c512011-11-29 18:15:50 +00002882 static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
Howard Hinnant5a646852012-04-02 21:00:45 +00002883 + _Working_result_type(1);
2884#else
2885 static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
2886 + _Working_result_type(1);
2887#endif
2888 static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
2889 static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
2890 static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002891
2892public:
2893 // constructors and seeding functions
2894 __independent_bits_engine(_Engine& __e, size_t __w);
2895
2896 // generating functions
Howard Hinnantc834c512011-11-29 18:15:50 +00002897 result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002898
2899private:
Marshall Clowfe778582017-09-20 19:38:43 +00002900 result_type __eval(false_type);
2901 result_type __eval(true_type);
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002902};
2903
2904template<class _Engine, class _UIntType>
2905__independent_bits_engine<_Engine, _UIntType>
2906 ::__independent_bits_engine(_Engine& __e, size_t __w)
2907 : __e_(__e),
2908 __w_(__w)
2909{
2910 __n_ = __w_ / __m + (__w_ % __m != 0);
2911 __w0_ = __w_ / __n_;
Howard Hinnantc834c512011-11-29 18:15:50 +00002912 if (_Rp == 0)
2913 __y0_ = _Rp;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002914 else if (__w0_ < _WDt)
Howard Hinnantc834c512011-11-29 18:15:50 +00002915 __y0_ = (_Rp >> __w0_) << __w0_;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002916 else
2917 __y0_ = 0;
Howard Hinnantc834c512011-11-29 18:15:50 +00002918 if (_Rp - __y0_ > __y0_ / __n_)
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002919 {
2920 ++__n_;
2921 __w0_ = __w_ / __n_;
2922 if (__w0_ < _WDt)
Howard Hinnantc834c512011-11-29 18:15:50 +00002923 __y0_ = (_Rp >> __w0_) << __w0_;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002924 else
2925 __y0_ = 0;
2926 }
2927 __n0_ = __n_ - __w_ % __n_;
2928 if (__w0_ < _WDt - 1)
Howard Hinnantc834c512011-11-29 18:15:50 +00002929 __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002930 else
2931 __y1_ = 0;
2932 __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) :
2933 _Engine_result_type(0);
2934 __mask1_ = __w0_ < _EDt - 1 ?
2935 _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) :
2936 _Engine_result_type(~0);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002937}
2938
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002939template<class _Engine, class _UIntType>
2940inline
2941_UIntType
Marshall Clowfe778582017-09-20 19:38:43 +00002942__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002943{
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002944 return static_cast<result_type>(__e_() & __mask0_);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002945}
2946
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002947template<class _Engine, class _UIntType>
2948_UIntType
Marshall Clowfe778582017-09-20 19:38:43 +00002949__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002950{
Marshall Clowafc48592017-09-20 17:34:11 +00002951 const size_t _WRt = numeric_limits<result_type>::digits;
Howard Hinnantc834c512011-11-29 18:15:50 +00002952 result_type _Sp = 0;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002953 for (size_t __k = 0; __k < __n0_; ++__k)
2954 {
2955 _Engine_result_type __u;
2956 do
2957 {
2958 __u = __e_() - _Engine::min();
2959 } while (__u >= __y0_);
Marshall Clowafc48592017-09-20 17:34:11 +00002960 if (__w0_ < _WRt)
Howard Hinnantc834c512011-11-29 18:15:50 +00002961 _Sp <<= __w0_;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002962 else
Howard Hinnantc834c512011-11-29 18:15:50 +00002963 _Sp = 0;
2964 _Sp += __u & __mask0_;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002965 }
2966 for (size_t __k = __n0_; __k < __n_; ++__k)
2967 {
2968 _Engine_result_type __u;
2969 do
2970 {
2971 __u = __e_() - _Engine::min();
2972 } while (__u >= __y1_);
Marshall Clowafc48592017-09-20 17:34:11 +00002973 if (__w0_ < _WRt - 1)
Howard Hinnantc834c512011-11-29 18:15:50 +00002974 _Sp <<= __w0_ + 1;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002975 else
Howard Hinnantc834c512011-11-29 18:15:50 +00002976 _Sp = 0;
2977 _Sp += __u & __mask1_;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002978 }
Howard Hinnantc834c512011-11-29 18:15:50 +00002979 return _Sp;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00002980}
2981
2982// uniform_int_distribution
2983
2984template<class _IntType = int>
2985class uniform_int_distribution
2986{
2987public:
2988 // types
2989 typedef _IntType result_type;
2990
2991 class param_type
2992 {
2993 result_type __a_;
2994 result_type __b_;
2995 public:
2996 typedef uniform_int_distribution distribution_type;
2997
2998 explicit param_type(result_type __a = 0,
2999 result_type __b = numeric_limits<result_type>::max())
3000 : __a_(__a), __b_(__b) {}
3001
3002 result_type a() const {return __a_;}
3003 result_type b() const {return __b_;}
3004
3005 friend bool operator==(const param_type& __x, const param_type& __y)
3006 {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
3007 friend bool operator!=(const param_type& __x, const param_type& __y)
3008 {return !(__x == __y);}
3009 };
3010
3011private:
3012 param_type __p_;
3013
3014public:
3015 // constructors and reset functions
Marek Kurdejcd0bd6a2021-01-19 08:21:09 +01003016#ifndef _LIBCPP_CXX03_LANG
3017 uniform_int_distribution() : uniform_int_distribution(0) {}
3018 explicit uniform_int_distribution(
3019 result_type __a, result_type __b = numeric_limits<result_type>::max())
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003020 : __p_(param_type(__a, __b)) {}
Marek Kurdejcd0bd6a2021-01-19 08:21:09 +01003021#else
3022 explicit uniform_int_distribution(
3023 result_type __a = 0,
3024 result_type __b = numeric_limits<result_type>::max())
3025 : __p_(param_type(__a, __b)) {}
3026#endif
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003027 explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
3028 void reset() {}
3029
3030 // generating functions
3031 template<class _URNG> result_type operator()(_URNG& __g)
3032 {return (*this)(__g, __p_);}
3033 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
3034
3035 // property functions
3036 result_type a() const {return __p_.a();}
3037 result_type b() const {return __p_.b();}
3038
3039 param_type param() const {return __p_;}
3040 void param(const param_type& __p) {__p_ = __p;}
3041
3042 result_type min() const {return a();}
3043 result_type max() const {return b();}
3044
3045 friend bool operator==(const uniform_int_distribution& __x,
3046 const uniform_int_distribution& __y)
3047 {return __x.__p_ == __y.__p_;}
3048 friend bool operator!=(const uniform_int_distribution& __x,
3049 const uniform_int_distribution& __y)
3050 {return !(__x == __y);}
3051};
3052
3053template<class _IntType>
3054template<class _URNG>
3055typename uniform_int_distribution<_IntType>::result_type
3056uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
Marshall Clowf79f4402018-10-08 20:20:34 +00003057_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003058{
3059 typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t),
3060 uint32_t, uint64_t>::type _UIntType;
Marshall Clowf79f4402018-10-08 20:20:34 +00003061 const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
Howard Hinnantc834c512011-11-29 18:15:50 +00003062 if (_Rp == 1)
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003063 return __p.a();
3064 const size_t _Dt = numeric_limits<_UIntType>::digits;
3065 typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
Howard Hinnantc834c512011-11-29 18:15:50 +00003066 if (_Rp == 0)
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003067 return static_cast<result_type>(_Eng(__g, _Dt)());
Marshall Clow370375e2019-07-12 01:01:55 +00003068 size_t __w = _Dt - __libcpp_clz(_Rp) - 1;
Arthur O'Dwyer07b22492020-11-27 11:02:06 -05003069 if ((_Rp & (numeric_limits<_UIntType>::max() >> (_Dt - __w))) != 0)
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003070 ++__w;
3071 _Eng __e(__g, __w);
3072 _UIntType __u;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003073 do
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003074 {
3075 __u = __e();
Howard Hinnantc834c512011-11-29 18:15:50 +00003076 } while (__u >= _Rp);
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003077 return static_cast<result_type>(__u + __p.a());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003078}
3079
Eric Fiselierf5fb27c2017-04-03 23:23:44 +00003080#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE) \
3081 || defined(_LIBCPP_BUILDING_LIBRARY)
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00003082class _LIBCPP_TYPE_VIS __rs_default;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003083
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00003084_LIBCPP_FUNC_VIS __rs_default __rs_get();
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003085
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00003086class _LIBCPP_TYPE_VIS __rs_default
Howard Hinnantc51e1022010-05-11 19:42:16 +00003087{
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003088 static unsigned __c_;
3089
3090 __rs_default();
3091public:
Marshall Clow9903c5b2013-02-07 22:12:02 +00003092 typedef uint_fast32_t result_type;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003093
3094 static const result_type _Min = 0;
3095 static const result_type _Max = 0xFFFFFFFF;
3096
3097 __rs_default(const __rs_default&);
3098 ~__rs_default();
3099
3100 result_type operator()();
3101
Howard Hinnant664183b2012-04-02 00:40:41 +00003102 static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
3103 static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003104
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00003105 friend _LIBCPP_FUNC_VIS __rs_default __rs_get();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003106};
3107
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00003108_LIBCPP_FUNC_VIS __rs_default __rs_get();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003109
3110template <class _RandomAccessIterator>
Louis Dionne481a2662018-09-23 18:35:00 +00003111_LIBCPP_DEPRECATED_IN_CXX14 void
Howard Hinnantc51e1022010-05-11 19:42:16 +00003112random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
3113{
3114 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
Howard Hinnantc834c512011-11-29 18:15:50 +00003115 typedef uniform_int_distribution<ptrdiff_t> _Dp;
3116 typedef typename _Dp::param_type _Pp;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003117 difference_type __d = __last - __first;
3118 if (__d > 1)
3119 {
Howard Hinnantc834c512011-11-29 18:15:50 +00003120 _Dp __uid;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003121 __rs_default __g = __rs_get();
Marshall Clowa224ace2019-01-24 19:20:19 +00003122 for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
Howard Hinnantc9bc02c2010-10-22 15:26:39 +00003123 {
Howard Hinnantc834c512011-11-29 18:15:50 +00003124 difference_type __i = __uid(__g, _Pp(0, __d));
Howard Hinnantc9bc02c2010-10-22 15:26:39 +00003125 if (__i != difference_type(0))
3126 swap(*__first, *(__first + __i));
3127 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00003128 }
3129}
3130
3131template <class _RandomAccessIterator, class _RandomNumberGenerator>
Louis Dionne481a2662018-09-23 18:35:00 +00003132_LIBCPP_DEPRECATED_IN_CXX14 void
Howard Hinnantc51e1022010-05-11 19:42:16 +00003133random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
Eric Fiselier93dd1372017-04-18 23:26:47 +00003134#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00003135 _RandomNumberGenerator&& __rand)
3136#else
3137 _RandomNumberGenerator& __rand)
3138#endif
3139{
3140 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
3141 difference_type __d = __last - __first;
3142 if (__d > 1)
3143 {
Marshall Clowa224ace2019-01-24 19:20:19 +00003144 for (--__last; __first < __last; ++__first, (void) --__d)
Howard Hinnantc9bc02c2010-10-22 15:26:39 +00003145 {
3146 difference_type __i = __rand(__d);
Marshall Clow5bdfc232018-09-11 18:33:45 +00003147 if (__i != difference_type(0))
Marshall Clowf79f4402018-10-08 20:20:34 +00003148 swap(*__first, *(__first + __i));
Howard Hinnantc9bc02c2010-10-22 15:26:39 +00003149 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00003150 }
3151}
Marshall Clowfac06e52017-03-23 13:43:37 +00003152#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00003153
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003154template <class _PopulationIterator, class _SampleIterator, class _Distance,
3155 class _UniformRandomNumberGenerator>
3156_LIBCPP_INLINE_VISIBILITY
3157_SampleIterator __sample(_PopulationIterator __first,
Alexander Richardsonc9637642017-11-14 11:14:25 +00003158 _PopulationIterator __last, _SampleIterator __output_iter,
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003159 _Distance __n,
3160 _UniformRandomNumberGenerator & __g,
3161 input_iterator_tag) {
3162
3163 _Distance __k = 0;
Marshall Clow0d332012019-08-20 21:31:51 +00003164 for (; __first != __last && __k < __n; ++__first, (void) ++__k)
Alexander Richardsonc9637642017-11-14 11:14:25 +00003165 __output_iter[__k] = *__first;
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003166 _Distance __sz = __k;
Marshall Clow0d332012019-08-20 21:31:51 +00003167 for (; __first != __last; ++__first, (void) ++__k) {
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003168 _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g);
3169 if (__r < __sz)
Alexander Richardsonc9637642017-11-14 11:14:25 +00003170 __output_iter[__r] = *__first;
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003171 }
Alexander Richardsonc9637642017-11-14 11:14:25 +00003172 return __output_iter + _VSTD::min(__n, __k);
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003173}
3174
3175template <class _PopulationIterator, class _SampleIterator, class _Distance,
3176 class _UniformRandomNumberGenerator>
3177_LIBCPP_INLINE_VISIBILITY
3178_SampleIterator __sample(_PopulationIterator __first,
Alexander Richardsonc9637642017-11-14 11:14:25 +00003179 _PopulationIterator __last, _SampleIterator __output_iter,
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003180 _Distance __n,
3181 _UniformRandomNumberGenerator& __g,
3182 forward_iterator_tag) {
3183 _Distance __unsampled_sz = _VSTD::distance(__first, __last);
3184 for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) {
3185 _Distance __r =
3186 _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g);
3187 if (__r < __n) {
Alexander Richardsonc9637642017-11-14 11:14:25 +00003188 *__output_iter++ = *__first;
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003189 --__n;
3190 }
3191 }
Alexander Richardsonc9637642017-11-14 11:14:25 +00003192 return __output_iter;
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003193}
3194
3195template <class _PopulationIterator, class _SampleIterator, class _Distance,
3196 class _UniformRandomNumberGenerator>
3197_LIBCPP_INLINE_VISIBILITY
3198_SampleIterator __sample(_PopulationIterator __first,
Alexander Richardsonc9637642017-11-14 11:14:25 +00003199 _PopulationIterator __last, _SampleIterator __output_iter,
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003200 _Distance __n, _UniformRandomNumberGenerator& __g) {
3201 typedef typename iterator_traits<_PopulationIterator>::iterator_category
3202 _PopCategory;
3203 typedef typename iterator_traits<_PopulationIterator>::difference_type
3204 _Difference;
Eric Fiseliercd5a6772019-11-18 01:46:58 -05003205 static_assert(__is_cpp17_forward_iterator<_PopulationIterator>::value ||
3206 __is_cpp17_random_access_iterator<_SampleIterator>::value,
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003207 "SampleIterator must meet the requirements of RandomAccessIterator");
3208 typedef typename common_type<_Distance, _Difference>::type _CommonType;
3209 _LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
3210 return _VSTD::__sample(
Alexander Richardsonc9637642017-11-14 11:14:25 +00003211 __first, __last, __output_iter, _CommonType(__n),
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003212 __g, _PopCategory());
3213}
3214
3215#if _LIBCPP_STD_VER > 14
3216template <class _PopulationIterator, class _SampleIterator, class _Distance,
3217 class _UniformRandomNumberGenerator>
3218inline _LIBCPP_INLINE_VISIBILITY
3219_SampleIterator sample(_PopulationIterator __first,
Alexander Richardsonc9637642017-11-14 11:14:25 +00003220 _PopulationIterator __last, _SampleIterator __output_iter,
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003221 _Distance __n, _UniformRandomNumberGenerator&& __g) {
Alexander Richardsonc9637642017-11-14 11:14:25 +00003222 return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
Eric Fiselier1208fcd2016-08-28 22:14:37 +00003223}
3224#endif // _LIBCPP_STD_VER > 14
3225
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003226template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
3227 void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
Howard Hinnanta5e71782010-11-18 01:47:02 +00003228 _UniformRandomNumberGenerator&& __g)
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003229{
3230 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
Howard Hinnantc834c512011-11-29 18:15:50 +00003231 typedef uniform_int_distribution<ptrdiff_t> _Dp;
3232 typedef typename _Dp::param_type _Pp;
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003233 difference_type __d = __last - __first;
3234 if (__d > 1)
3235 {
Howard Hinnantc834c512011-11-29 18:15:50 +00003236 _Dp __uid;
Marshall Clow0d332012019-08-20 21:31:51 +00003237 for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
Howard Hinnantc9bc02c2010-10-22 15:26:39 +00003238 {
Howard Hinnantc834c512011-11-29 18:15:50 +00003239 difference_type __i = __uid(__g, _Pp(0, __d));
Howard Hinnantc9bc02c2010-10-22 15:26:39 +00003240 if (__i != difference_type(0))
3241 swap(*__first, *(__first + __i));
3242 }
Howard Hinnant578ac0f2010-05-26 17:49:34 +00003243 }
3244}
3245
Arthur O'Dwyercea050d2020-12-26 01:39:03 -05003246#if _LIBCPP_STD_VER > 17
3247
3248// shift_left, shift_right
3249
3250template <class _ForwardIterator>
3251inline _LIBCPP_INLINE_VISIBILITY constexpr
3252_ForwardIterator
3253shift_left(_ForwardIterator __first, _ForwardIterator __last,
3254 typename iterator_traits<_ForwardIterator>::difference_type __n)
3255{
3256 if (__n == 0) {
3257 return __last;
3258 }
3259
3260 _ForwardIterator __m = __first;
3261 if constexpr (__is_cpp17_random_access_iterator<_ForwardIterator>::value) {
3262 if (__n >= __last - __first) {
3263 return __first;
3264 }
3265 __m += __n;
3266 } else {
3267 for (; __n > 0; --__n) {
3268 if (__m == __last) {
3269 return __first;
3270 }
3271 ++__m;
3272 }
3273 }
3274 return _VSTD::move(__m, __last, __first);
3275}
3276
3277template <class _ForwardIterator>
3278inline _LIBCPP_INLINE_VISIBILITY constexpr
3279_ForwardIterator
3280shift_right(_ForwardIterator __first, _ForwardIterator __last,
3281 typename iterator_traits<_ForwardIterator>::difference_type __n)
3282{
3283 if (__n == 0) {
3284 return __first;
3285 }
3286
3287 if constexpr (__is_cpp17_random_access_iterator<_ForwardIterator>::value) {
3288 decltype(__n) __d = __last - __first;
3289 if (__n >= __d) {
3290 return __last;
3291 }
3292 _ForwardIterator __m = __first + (__d - __n);
3293 return _VSTD::move_backward(__first, __m, __last);
3294 } else if constexpr (__is_cpp17_bidirectional_iterator<_ForwardIterator>::value) {
3295 _ForwardIterator __m = __last;
3296 for (; __n > 0; --__n) {
3297 if (__m == __first) {
3298 return __last;
3299 }
3300 --__m;
3301 }
3302 return _VSTD::move_backward(__first, __m, __last);
3303 } else {
3304 _ForwardIterator __ret = __first;
3305 for (; __n > 0; --__n) {
3306 if (__ret == __last) {
3307 return __last;
3308 }
3309 ++__ret;
3310 }
3311
3312 // We have an __n-element scratch space from __first to __ret.
3313 // Slide an __n-element window [__trail, __lead) from left to right.
3314 // We're essentially doing swap_ranges(__first, __ret, __trail, __lead)
3315 // over and over; but once __lead reaches __last we needn't bother
3316 // to save the values of elements [__trail, __last).
3317
3318 auto __trail = __first;
3319 auto __lead = __ret;
3320 while (__trail != __ret) {
3321 if (__lead == __last) {
3322 _VSTD::move(__first, __trail, __ret);
3323 return __ret;
3324 }
3325 ++__trail;
3326 ++__lead;
3327 }
3328
3329 _ForwardIterator __mid = __first;
3330 while (true) {
3331 if (__lead == __last) {
3332 __trail = _VSTD::move(__mid, __ret, __trail);
3333 _VSTD::move(__first, __mid, __trail);
3334 return __ret;
3335 }
3336 swap(*__mid, *__trail);
3337 ++__mid;
3338 ++__trail;
3339 ++__lead;
3340 if (__mid == __ret) {
3341 __mid = __first;
3342 }
3343 }
3344 }
3345}
3346
3347#endif // _LIBCPP_STD_VER > 17
3348
3349// is_partitioned
3350
Howard Hinnantc51e1022010-05-11 19:42:16 +00003351template <class _InputIterator, class _Predicate>
Nico Weber471b10a2019-04-03 18:13:08 +00003352_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00003353is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
3354{
3355 for (; __first != __last; ++__first)
3356 if (!__pred(*__first))
3357 break;
Marshall Clow3562ed72015-02-02 18:16:35 +00003358 if ( __first == __last )
3359 return true;
3360 ++__first;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003361 for (; __first != __last; ++__first)
3362 if (__pred(*__first))
3363 return false;
3364 return true;
3365}
3366
3367// partition
3368
3369template <class _Predicate, class _ForwardIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05003370_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00003371__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)
3372{
3373 while (true)
3374 {
3375 if (__first == __last)
3376 return __first;
3377 if (!__pred(*__first))
3378 break;
3379 ++__first;
3380 }
3381 for (_ForwardIterator __p = __first; ++__p != __last;)
3382 {
3383 if (__pred(*__p))
3384 {
3385 swap(*__first, *__p);
3386 ++__first;
3387 }
3388 }
3389 return __first;
3390}
3391
3392template <class _Predicate, class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05003393_LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00003394__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
3395 bidirectional_iterator_tag)
3396{
3397 while (true)
3398 {
3399 while (true)
3400 {
3401 if (__first == __last)
3402 return __first;
3403 if (!__pred(*__first))
3404 break;
3405 ++__first;
3406 }
3407 do
3408 {
3409 if (__first == --__last)
3410 return __first;
3411 } while (!__pred(*__last));
3412 swap(*__first, *__last);
3413 ++__first;
3414 }
3415}
3416
3417template <class _ForwardIterator, class _Predicate>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05003418inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00003419_ForwardIterator
3420partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
3421{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003422 return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00003423 (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
3424}
3425
3426// partition_copy
3427
3428template <class _InputIterator, class _OutputIterator1,
3429 class _OutputIterator2, class _Predicate>
Marshall Clow5492c8a2018-01-22 20:44:33 +00003430_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_OutputIterator1, _OutputIterator2>
Howard Hinnantc51e1022010-05-11 19:42:16 +00003431partition_copy(_InputIterator __first, _InputIterator __last,
3432 _OutputIterator1 __out_true, _OutputIterator2 __out_false,
3433 _Predicate __pred)
3434{
3435 for (; __first != __last; ++__first)
3436 {
3437 if (__pred(*__first))
3438 {
3439 *__out_true = *__first;
3440 ++__out_true;
3441 }
3442 else
3443 {
3444 *__out_false = *__first;
3445 ++__out_false;
3446 }
3447 }
3448 return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
3449}
3450
3451// partition_point
3452
3453template<class _ForwardIterator, class _Predicate>
Marshall Clowcb3c8262018-01-15 17:53:34 +00003454_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00003455partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
3456{
3457 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003458 difference_type __len = _VSTD::distance(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003459 while (__len != 0)
3460 {
Louis Dionnedda14512018-12-17 16:04:39 +00003461 difference_type __l2 = _VSTD::__half_positive(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003462 _ForwardIterator __m = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003463 _VSTD::advance(__m, __l2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003464 if (__pred(*__m))
3465 {
3466 __first = ++__m;
3467 __len -= __l2 + 1;
3468 }
3469 else
3470 __len = __l2;
3471 }
3472 return __first;
3473}
3474
3475// stable_partition
3476
3477template <class _Predicate, class _ForwardIterator, class _Distance, class _Pair>
3478_ForwardIterator
3479__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
3480 _Distance __len, _Pair __p, forward_iterator_tag __fit)
3481{
3482 // *__first is known to be false
3483 // __len >= 1
3484 if (__len == 1)
3485 return __first;
3486 if (__len == 2)
3487 {
3488 _ForwardIterator __m = __first;
3489 if (__pred(*++__m))
3490 {
3491 swap(*__first, *__m);
3492 return __m;
3493 }
3494 return __first;
3495 }
3496 if (__len <= __p.second)
3497 { // The buffer is big enough to use
3498 typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
3499 __destruct_n __d(0);
3500 unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
3501 // Move the falses into the temporary buffer, and the trues to the front of the line
3502 // Update __first to always point to the end of the trues
3503 value_type* __t = __p.first;
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05003504 ::new ((void*)__t) value_type(_VSTD::move(*__first));
Bruce Mitchener170d8972020-11-24 12:53:53 -05003505 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003506 ++__t;
3507 _ForwardIterator __i = __first;
3508 while (++__i != __last)
3509 {
3510 if (__pred(*__i))
3511 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003512 *__first = _VSTD::move(*__i);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003513 ++__first;
3514 }
3515 else
3516 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05003517 ::new ((void*)__t) value_type(_VSTD::move(*__i));
Bruce Mitchener170d8972020-11-24 12:53:53 -05003518 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003519 ++__t;
3520 }
3521 }
3522 // All trues now at start of range, all falses in buffer
3523 // Move falses back into range, but don't mess up __first which points to first false
3524 __i = __first;
Marshall Clow0d332012019-08-20 21:31:51 +00003525 for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003526 *__i = _VSTD::move(*__t2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003527 // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
3528 return __first;
3529 }
3530 // Else not enough buffer, do in place
3531 // __len >= 3
3532 _ForwardIterator __m = __first;
3533 _Distance __len2 = __len / 2; // __len2 >= 2
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003534 _VSTD::advance(__m, __len2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003535 // recurse on [__first, __m), *__first know to be false
3536 // F?????????????????
3537 // f m l
3538 typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003539 _ForwardIterator __first_false = _VSTD::__stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003540 // TTTFFFFF??????????
3541 // f ff m l
3542 // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
3543 _ForwardIterator __m1 = __m;
3544 _ForwardIterator __second_false = __last;
3545 _Distance __len_half = __len - __len2;
3546 while (__pred(*__m1))
3547 {
3548 if (++__m1 == __last)
3549 goto __second_half_done;
3550 --__len_half;
3551 }
3552 // TTTFFFFFTTTF??????
3553 // f ff m m1 l
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003554 __second_false = _VSTD::__stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003555__second_half_done:
3556 // TTTFFFFFTTTTTFFFFF
3557 // f ff m sf l
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003558 return _VSTD::rotate(__first_false, __m, __second_false);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003559 // TTTTTTTTFFFFFFFFFF
3560 // |
3561}
3562
3563struct __return_temporary_buffer
3564{
3565 template <class _Tp>
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003566 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00003567};
3568
3569template <class _Predicate, class _ForwardIterator>
3570_ForwardIterator
3571__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
3572 forward_iterator_tag)
3573{
3574 const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment
3575 // Either prove all true and return __first or point to first false
3576 while (true)
3577 {
3578 if (__first == __last)
3579 return __first;
3580 if (!__pred(*__first))
3581 break;
3582 ++__first;
3583 }
3584 // We now have a reduced range [__first, __last)
3585 // *__first is known to be false
3586 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
3587 typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003588 difference_type __len = _VSTD::distance(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003589 pair<value_type*, ptrdiff_t> __p(0, 0);
3590 unique_ptr<value_type, __return_temporary_buffer> __h;
3591 if (__len >= __alloc_limit)
3592 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003593 __p = _VSTD::get_temporary_buffer<value_type>(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003594 __h.reset(__p.first);
3595 }
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003596 return _VSTD::__stable_partition<typename add_lvalue_reference<_Predicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00003597 (__first, __last, __pred, __len, __p, forward_iterator_tag());
3598}
3599
3600template <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair>
3601_BidirectionalIterator
3602__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
3603 _Distance __len, _Pair __p, bidirectional_iterator_tag __bit)
3604{
3605 // *__first is known to be false
3606 // *__last is known to be true
3607 // __len >= 2
3608 if (__len == 2)
3609 {
3610 swap(*__first, *__last);
3611 return __last;
3612 }
3613 if (__len == 3)
3614 {
3615 _BidirectionalIterator __m = __first;
3616 if (__pred(*++__m))
3617 {
3618 swap(*__first, *__m);
3619 swap(*__m, *__last);
3620 return __last;
3621 }
3622 swap(*__m, *__last);
3623 swap(*__first, *__m);
3624 return __m;
3625 }
3626 if (__len <= __p.second)
3627 { // The buffer is big enough to use
3628 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
3629 __destruct_n __d(0);
3630 unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
3631 // Move the falses into the temporary buffer, and the trues to the front of the line
3632 // Update __first to always point to the end of the trues
3633 value_type* __t = __p.first;
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05003634 ::new ((void*)__t) value_type(_VSTD::move(*__first));
Bruce Mitchener170d8972020-11-24 12:53:53 -05003635 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003636 ++__t;
3637 _BidirectionalIterator __i = __first;
3638 while (++__i != __last)
3639 {
3640 if (__pred(*__i))
3641 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003642 *__first = _VSTD::move(*__i);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003643 ++__first;
3644 }
3645 else
3646 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05003647 ::new ((void*)__t) value_type(_VSTD::move(*__i));
Bruce Mitchener170d8972020-11-24 12:53:53 -05003648 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003649 ++__t;
3650 }
3651 }
3652 // move *__last, known to be true
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003653 *__first = _VSTD::move(*__i);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003654 __i = ++__first;
3655 // All trues now at start of range, all falses in buffer
3656 // Move falses back into range, but don't mess up __first which points to first false
Marshall Clow0d332012019-08-20 21:31:51 +00003657 for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003658 *__i = _VSTD::move(*__t2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003659 // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
3660 return __first;
3661 }
3662 // Else not enough buffer, do in place
3663 // __len >= 4
3664 _BidirectionalIterator __m = __first;
3665 _Distance __len2 = __len / 2; // __len2 >= 2
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003666 _VSTD::advance(__m, __len2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003667 // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false
3668 // F????????????????T
3669 // f m l
3670 _BidirectionalIterator __m1 = __m;
3671 _BidirectionalIterator __first_false = __first;
3672 _Distance __len_half = __len2;
3673 while (!__pred(*--__m1))
3674 {
3675 if (__m1 == __first)
3676 goto __first_half_done;
3677 --__len_half;
3678 }
3679 // F???TFFF?????????T
3680 // f m1 m l
3681 typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003682 __first_false = _VSTD::__stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003683__first_half_done:
3684 // TTTFFFFF?????????T
3685 // f ff m l
3686 // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
3687 __m1 = __m;
3688 _BidirectionalIterator __second_false = __last;
3689 ++__second_false;
3690 __len_half = __len - __len2;
3691 while (__pred(*__m1))
3692 {
3693 if (++__m1 == __last)
3694 goto __second_half_done;
3695 --__len_half;
3696 }
3697 // TTTFFFFFTTTF?????T
3698 // f ff m m1 l
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003699 __second_false = _VSTD::__stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003700__second_half_done:
3701 // TTTFFFFFTTTTTFFFFF
3702 // f ff m sf l
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003703 return _VSTD::rotate(__first_false, __m, __second_false);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003704 // TTTTTTTTFFFFFFFFFF
3705 // |
3706}
3707
3708template <class _Predicate, class _BidirectionalIterator>
3709_BidirectionalIterator
3710__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
3711 bidirectional_iterator_tag)
3712{
3713 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
3714 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
3715 const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment
3716 // Either prove all true and return __first or point to first false
3717 while (true)
3718 {
3719 if (__first == __last)
3720 return __first;
3721 if (!__pred(*__first))
3722 break;
3723 ++__first;
3724 }
3725 // __first points to first false, everything prior to __first is already set.
3726 // Either prove [__first, __last) is all false and return __first, or point __last to last true
3727 do
3728 {
3729 if (__first == --__last)
3730 return __first;
3731 } while (!__pred(*__last));
3732 // We now have a reduced range [__first, __last]
3733 // *__first is known to be false
3734 // *__last is known to be true
3735 // __len >= 2
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003736 difference_type __len = _VSTD::distance(__first, __last) + 1;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003737 pair<value_type*, ptrdiff_t> __p(0, 0);
3738 unique_ptr<value_type, __return_temporary_buffer> __h;
3739 if (__len >= __alloc_limit)
3740 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003741 __p = _VSTD::get_temporary_buffer<value_type>(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003742 __h.reset(__p.first);
3743 }
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003744 return _VSTD::__stable_partition<typename add_lvalue_reference<_Predicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00003745 (__first, __last, __pred, __len, __p, bidirectional_iterator_tag());
3746}
3747
3748template <class _ForwardIterator, class _Predicate>
3749inline _LIBCPP_INLINE_VISIBILITY
3750_ForwardIterator
3751stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
3752{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003753 return _VSTD::__stable_partition<typename add_lvalue_reference<_Predicate>::type>
Howard Hinnantc51e1022010-05-11 19:42:16 +00003754 (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
3755}
3756
3757// is_sorted_until
3758
3759template <class _ForwardIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00003760_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00003761is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
3762{
3763 if (__first != __last)
3764 {
3765 _ForwardIterator __i = __first;
3766 while (++__i != __last)
3767 {
3768 if (__comp(*__i, *__first))
3769 return __i;
3770 __first = __i;
3771 }
3772 }
3773 return __last;
3774}
3775
Howard Hinnant3b6579a2010-08-22 00:02:43 +00003776template<class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00003777_LIBCPP_NODISCARD_EXT inline
3778_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00003779_ForwardIterator
3780is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
3781{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003782 return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003783}
3784
3785// is_sorted
3786
3787template <class _ForwardIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00003788_LIBCPP_NODISCARD_EXT inline
3789_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00003790bool
3791is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
3792{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003793 return _VSTD::is_sorted_until(__first, __last, __comp) == __last;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003794}
3795
Howard Hinnant3b6579a2010-08-22 00:02:43 +00003796template<class _ForwardIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00003797_LIBCPP_NODISCARD_EXT inline
3798_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00003799bool
3800is_sorted(_ForwardIterator __first, _ForwardIterator __last)
3801{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003802 return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003803}
3804
3805// sort
3806
3807// stable, 2-3 compares, 0-2 swaps
3808
3809template <class _Compare, class _ForwardIterator>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08003810unsigned
Howard Hinnantc51e1022010-05-11 19:42:16 +00003811__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c)
3812{
3813 unsigned __r = 0;
3814 if (!__c(*__y, *__x)) // if x <= y
3815 {
3816 if (!__c(*__z, *__y)) // if y <= z
3817 return __r; // x <= y && y <= z
3818 // x <= y && y > z
3819 swap(*__y, *__z); // x <= z && y < z
3820 __r = 1;
3821 if (__c(*__y, *__x)) // if x > y
3822 {
3823 swap(*__x, *__y); // x < y && y <= z
3824 __r = 2;
3825 }
3826 return __r; // x <= y && y < z
3827 }
3828 if (__c(*__z, *__y)) // x > y, if y > z
3829 {
3830 swap(*__x, *__z); // x < y && y < z
3831 __r = 1;
3832 return __r;
3833 }
3834 swap(*__x, *__y); // x > y && y <= z
3835 __r = 1; // x < y && x <= z
3836 if (__c(*__z, *__y)) // if y > z
3837 {
3838 swap(*__y, *__z); // x <= y && y < z
3839 __r = 2;
3840 }
3841 return __r;
3842} // x <= y && y <= z
3843
3844// stable, 3-6 compares, 0-5 swaps
3845
3846template <class _Compare, class _ForwardIterator>
3847unsigned
3848__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
3849 _ForwardIterator __x4, _Compare __c)
3850{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003851 unsigned __r = _VSTD::__sort3<_Compare>(__x1, __x2, __x3, __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003852 if (__c(*__x4, *__x3))
3853 {
3854 swap(*__x3, *__x4);
3855 ++__r;
3856 if (__c(*__x3, *__x2))
3857 {
3858 swap(*__x2, *__x3);
3859 ++__r;
3860 if (__c(*__x2, *__x1))
3861 {
3862 swap(*__x1, *__x2);
3863 ++__r;
3864 }
3865 }
3866 }
3867 return __r;
3868}
3869
3870// stable, 4-10 compares, 0-9 swaps
3871
3872template <class _Compare, class _ForwardIterator>
Louis Dionne9e70e362018-11-21 16:24:46 +00003873_LIBCPP_HIDDEN
Howard Hinnantc51e1022010-05-11 19:42:16 +00003874unsigned
3875__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
3876 _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c)
3877{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003878 unsigned __r = _VSTD::__sort4<_Compare>(__x1, __x2, __x3, __x4, __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003879 if (__c(*__x5, *__x4))
3880 {
3881 swap(*__x4, *__x5);
3882 ++__r;
3883 if (__c(*__x4, *__x3))
3884 {
3885 swap(*__x3, *__x4);
3886 ++__r;
3887 if (__c(*__x3, *__x2))
3888 {
3889 swap(*__x2, *__x3);
3890 ++__r;
3891 if (__c(*__x2, *__x1))
3892 {
3893 swap(*__x1, *__x2);
3894 ++__r;
3895 }
3896 }
3897 }
3898 }
3899 return __r;
3900}
3901
3902// Assumes size > 0
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003903template <class _Compare, class _BidirectionalIterator>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08003904void
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003905__selection_sort(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003906{
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003907 _BidirectionalIterator __lm1 = __last;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003908 for (--__lm1; __first != __lm1; ++__first)
3909 {
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003910 _BidirectionalIterator __i = _VSTD::min_element<_BidirectionalIterator,
Howard Hinnantc51e1022010-05-11 19:42:16 +00003911 typename add_lvalue_reference<_Compare>::type>
3912 (__first, __last, __comp);
3913 if (__i != __first)
3914 swap(*__first, *__i);
3915 }
3916}
3917
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003918template <class _Compare, class _BidirectionalIterator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00003919void
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003920__insertion_sort(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003921{
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003922 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003923 if (__first != __last)
3924 {
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003925 _BidirectionalIterator __i = __first;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003926 for (++__i; __i != __last; ++__i)
3927 {
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003928 _BidirectionalIterator __j = __i;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003929 value_type __t(_VSTD::move(*__j));
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05003930 for (_BidirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003931 *__j = _VSTD::move(*__k);
3932 *__j = _VSTD::move(__t);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003933 }
3934 }
3935}
3936
3937template <class _Compare, class _RandomAccessIterator>
3938void
3939__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
3940{
3941 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
3942 _RandomAccessIterator __j = __first+2;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003943 _VSTD::__sort3<_Compare>(__first, __first+1, __j, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003944 for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
3945 {
3946 if (__comp(*__i, *__j))
3947 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003948 value_type __t(_VSTD::move(*__i));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003949 _RandomAccessIterator __k = __j;
3950 __j = __i;
3951 do
3952 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003953 *__j = _VSTD::move(*__k);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003954 __j = __k;
3955 } while (__j != __first && __comp(__t, *--__k));
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003956 *__j = _VSTD::move(__t);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003957 }
3958 __j = __i;
3959 }
3960}
3961
3962template <class _Compare, class _RandomAccessIterator>
3963bool
3964__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
3965{
3966 switch (__last - __first)
3967 {
3968 case 0:
3969 case 1:
3970 return true;
3971 case 2:
3972 if (__comp(*--__last, *__first))
3973 swap(*__first, *__last);
3974 return true;
3975 case 3:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003976 _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003977 return true;
3978 case 4:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003979 _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003980 return true;
3981 case 5:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003982 _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003983 return true;
3984 }
3985 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
3986 _RandomAccessIterator __j = __first+2;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05003987 _VSTD::__sort3<_Compare>(__first, __first+1, __j, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003988 const unsigned __limit = 8;
3989 unsigned __count = 0;
3990 for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
3991 {
3992 if (__comp(*__i, *__j))
3993 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003994 value_type __t(_VSTD::move(*__i));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003995 _RandomAccessIterator __k = __j;
3996 __j = __i;
3997 do
3998 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003999 *__j = _VSTD::move(*__k);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004000 __j = __k;
4001 } while (__j != __first && __comp(__t, *--__k));
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004002 *__j = _VSTD::move(__t);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004003 if (++__count == __limit)
4004 return ++__i == __last;
4005 }
4006 __j = __i;
4007 }
4008 return true;
4009}
4010
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05004011template <class _Compare, class _BidirectionalIterator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00004012void
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05004013__insertion_sort_move(_BidirectionalIterator __first1, _BidirectionalIterator __last1,
4014 typename iterator_traits<_BidirectionalIterator>::value_type* __first2, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004015{
Arthur O'Dwyerb3b2d732020-12-12 11:37:36 -05004016 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004017 if (__first1 != __last1)
4018 {
4019 __destruct_n __d(0);
4020 unique_ptr<value_type, __destruct_n&> __h(__first2, __d);
4021 value_type* __last2 = __first2;
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004022 ::new ((void*)__last2) value_type(_VSTD::move(*__first1));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004023 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004024 for (++__last2; ++__first1 != __last1; ++__last2)
4025 {
4026 value_type* __j2 = __last2;
4027 value_type* __i2 = __j2;
4028 if (__comp(*__first1, *--__i2))
4029 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004030 ::new ((void*)__j2) value_type(_VSTD::move(*__i2));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004031 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004032 for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004033 *__j2 = _VSTD::move(*__i2);
4034 *__j2 = _VSTD::move(*__first1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004035 }
4036 else
4037 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004038 ::new ((void*)__j2) value_type(_VSTD::move(*__first1));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004039 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004040 }
4041 }
4042 __h.release();
4043 }
4044}
4045
4046template <class _Compare, class _RandomAccessIterator>
4047void
4048__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4049{
Howard Hinnantc51e1022010-05-11 19:42:16 +00004050 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4051 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
Howard Hinnanta9a897e2010-11-19 22:17:28 +00004052 const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
4053 is_trivially_copy_assignable<value_type>::value ? 30 : 6;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004054 while (true)
4055 {
4056 __restart:
4057 difference_type __len = __last - __first;
4058 switch (__len)
4059 {
4060 case 0:
4061 case 1:
4062 return;
4063 case 2:
4064 if (__comp(*--__last, *__first))
4065 swap(*__first, *__last);
4066 return;
4067 case 3:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004068 _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004069 return;
4070 case 4:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004071 _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004072 return;
4073 case 5:
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004074 _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004075 return;
4076 }
4077 if (__len <= __limit)
4078 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004079 _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004080 return;
4081 }
4082 // __len > 5
4083 _RandomAccessIterator __m = __first;
4084 _RandomAccessIterator __lm1 = __last;
4085 --__lm1;
4086 unsigned __n_swaps;
4087 {
4088 difference_type __delta;
4089 if (__len >= 1000)
4090 {
4091 __delta = __len/2;
4092 __m += __delta;
4093 __delta /= 2;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004094 __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004095 }
4096 else
4097 {
4098 __delta = __len/2;
4099 __m += __delta;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004100 __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004101 }
4102 }
4103 // *__m is median
4104 // partition [__first, __m) < *__m and *__m <= [__m, __last)
4105 // (this inhibits tossing elements equivalent to __m around unnecessarily)
4106 _RandomAccessIterator __i = __first;
4107 _RandomAccessIterator __j = __lm1;
4108 // j points beyond range to be tested, *__m is known to be <= *__lm1
4109 // The search going up is known to be guarded but the search coming down isn't.
4110 // Prime the downward search with a guard.
4111 if (!__comp(*__i, *__m)) // if *__first == *__m
4112 {
4113 // *__first == *__m, *__first doesn't go in first part
4114 // manually guard downward moving __j against __i
4115 while (true)
4116 {
4117 if (__i == --__j)
4118 {
4119 // *__first == *__m, *__m <= all other elements
4120 // Parition instead into [__first, __i) == *__first and *__first < [__i, __last)
4121 ++__i; // __first + 1
4122 __j = __last;
4123 if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1)
4124 {
4125 while (true)
4126 {
4127 if (__i == __j)
4128 return; // [__first, __last) all equivalent elements
4129 if (__comp(*__first, *__i))
4130 {
4131 swap(*__i, *__j);
4132 ++__n_swaps;
4133 ++__i;
4134 break;
4135 }
4136 ++__i;
4137 }
4138 }
4139 // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
4140 if (__i == __j)
4141 return;
4142 while (true)
4143 {
4144 while (!__comp(*__first, *__i))
4145 ++__i;
4146 while (__comp(*__first, *--__j))
4147 ;
4148 if (__i >= __j)
4149 break;
4150 swap(*__i, *__j);
4151 ++__n_swaps;
4152 ++__i;
4153 }
4154 // [__first, __i) == *__first and *__first < [__i, __last)
Arthur O'Dwyerdf5df562020-12-12 11:57:32 -05004155 // The first part is sorted, sort the second part
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004156 // _VSTD::__sort<_Compare>(__i, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004157 __first = __i;
4158 goto __restart;
4159 }
4160 if (__comp(*__j, *__m))
4161 {
4162 swap(*__i, *__j);
4163 ++__n_swaps;
4164 break; // found guard for downward moving __j, now use unguarded partition
4165 }
4166 }
4167 }
4168 // It is known that *__i < *__m
4169 ++__i;
4170 // j points beyond range to be tested, *__m is known to be <= *__lm1
4171 // if not yet partitioned...
4172 if (__i < __j)
4173 {
4174 // known that *(__i - 1) < *__m
4175 // known that __i <= __m
4176 while (true)
4177 {
4178 // __m still guards upward moving __i
4179 while (__comp(*__i, *__m))
4180 ++__i;
4181 // It is now known that a guard exists for downward moving __j
4182 while (!__comp(*--__j, *__m))
4183 ;
4184 if (__i > __j)
4185 break;
4186 swap(*__i, *__j);
4187 ++__n_swaps;
4188 // It is known that __m != __j
4189 // If __m just moved, follow it
4190 if (__m == __i)
4191 __m = __j;
4192 ++__i;
4193 }
4194 }
4195 // [__first, __i) < *__m and *__m <= [__i, __last)
4196 if (__i != __m && __comp(*__m, *__i))
4197 {
4198 swap(*__i, *__m);
4199 ++__n_swaps;
4200 }
4201 // [__first, __i) < *__i and *__i <= [__i+1, __last)
4202 // If we were given a perfect partition, see if insertion sort is quick...
4203 if (__n_swaps == 0)
4204 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004205 bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
4206 if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004207 {
4208 if (__fs)
4209 return;
4210 __last = __i;
4211 continue;
4212 }
4213 else
4214 {
4215 if (__fs)
4216 {
4217 __first = ++__i;
4218 continue;
4219 }
4220 }
4221 }
4222 // sort smaller range with recursive call and larger with tail recursion elimination
4223 if (__i - __first < __last - __i)
4224 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004225 _VSTD::__sort<_Compare>(__first, __i, __comp);
4226 // _VSTD::__sort<_Compare>(__i+1, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004227 __first = ++__i;
4228 }
4229 else
4230 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004231 _VSTD::__sort<_Compare>(__i+1, __last, __comp);
4232 // _VSTD::__sort<_Compare>(__first, __i, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004233 __last = __i;
4234 }
4235 }
4236}
4237
Arthur O'Dwyer1bb0f672020-12-20 15:21:42 -05004238template <class _Compare, class _Tp>
Howard Hinnantc51e1022010-05-11 19:42:16 +00004239inline _LIBCPP_INLINE_VISIBILITY
4240void
Arthur O'Dwyer1bb0f672020-12-20 15:21:42 -05004241__sort(_Tp** __first, _Tp** __last, __less<_Tp*>&)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004242{
Arthur O'Dwyer1bb0f672020-12-20 15:21:42 -05004243 __less<uintptr_t> __comp;
4244 _VSTD::__sort<__less<uintptr_t>&, uintptr_t*>((uintptr_t*)__first, (uintptr_t*)__last, __comp);
Howard Hinnant27e0e772011-09-14 18:33:51 +00004245}
4246
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004247_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&))
4248_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
4249_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
4250_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
4251_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&))
4252_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
4253_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&))
4254_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
4255_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&))
4256_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
4257_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
4258_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
4259_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&))
4260_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&))
4261_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004262
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004263_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&))
4264_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
4265_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
4266_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
4267_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&))
4268_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
4269_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&))
4270_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
4271_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&))
4272_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
4273_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
4274_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
4275_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&))
4276_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&))
4277_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004278
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004279_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004280
4281// lower_bound
4282
4283template <class _Compare, class _ForwardIterator, class _Tp>
Marshall Clowe00916c2018-01-16 02:34:41 +00004284_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00004285__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004286{
4287 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004288 difference_type __len = _VSTD::distance(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004289 while (__len != 0)
4290 {
Louis Dionnedda14512018-12-17 16:04:39 +00004291 difference_type __l2 = _VSTD::__half_positive(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004292 _ForwardIterator __m = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004293 _VSTD::advance(__m, __l2);
Howard Hinnantbf074022011-10-22 20:59:45 +00004294 if (__comp(*__m, __value_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004295 {
4296 __first = ++__m;
4297 __len -= __l2 + 1;
4298 }
4299 else
4300 __len = __l2;
4301 }
4302 return __first;
4303}
4304
4305template <class _ForwardIterator, class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00004306_LIBCPP_NODISCARD_EXT inline
4307_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004308_ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00004309lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004310{
Howard Hinnantc51e1022010-05-11 19:42:16 +00004311 typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004312 return _VSTD::__lower_bound<_Comp_ref>(__first, __last, __value_, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004313}
4314
4315template <class _ForwardIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00004316_LIBCPP_NODISCARD_EXT inline
4317_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004318_ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00004319lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004320{
Howard Hinnantbf074022011-10-22 20:59:45 +00004321 return _VSTD::lower_bound(__first, __last, __value_,
Howard Hinnantc51e1022010-05-11 19:42:16 +00004322 __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
4323}
4324
4325// upper_bound
4326
4327template <class _Compare, class _ForwardIterator, class _Tp>
Marshall Clowe00916c2018-01-16 02:34:41 +00004328_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00004329__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004330{
4331 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004332 difference_type __len = _VSTD::distance(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004333 while (__len != 0)
4334 {
Louis Dionnedda14512018-12-17 16:04:39 +00004335 difference_type __l2 = _VSTD::__half_positive(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004336 _ForwardIterator __m = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004337 _VSTD::advance(__m, __l2);
Howard Hinnantbf074022011-10-22 20:59:45 +00004338 if (__comp(__value_, *__m))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004339 __len = __l2;
4340 else
4341 {
4342 __first = ++__m;
4343 __len -= __l2 + 1;
4344 }
4345 }
4346 return __first;
4347}
4348
4349template <class _ForwardIterator, class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00004350_LIBCPP_NODISCARD_EXT inline
4351_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004352_ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00004353upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004354{
Howard Hinnantc51e1022010-05-11 19:42:16 +00004355 typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004356 return _VSTD::__upper_bound<_Comp_ref>(__first, __last, __value_, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004357}
4358
4359template <class _ForwardIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00004360_LIBCPP_NODISCARD_EXT inline
4361_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004362_ForwardIterator
Howard Hinnantbf074022011-10-22 20:59:45 +00004363upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004364{
Howard Hinnantbf074022011-10-22 20:59:45 +00004365 return _VSTD::upper_bound(__first, __last, __value_,
Howard Hinnantc51e1022010-05-11 19:42:16 +00004366 __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
4367}
4368
4369// equal_range
4370
4371template <class _Compare, class _ForwardIterator, class _Tp>
Marshall Clowe00916c2018-01-16 02:34:41 +00004372_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator>
Howard Hinnantbf074022011-10-22 20:59:45 +00004373__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004374{
4375 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004376 difference_type __len = _VSTD::distance(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004377 while (__len != 0)
4378 {
Louis Dionnedda14512018-12-17 16:04:39 +00004379 difference_type __l2 = _VSTD::__half_positive(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004380 _ForwardIterator __m = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004381 _VSTD::advance(__m, __l2);
Howard Hinnantbf074022011-10-22 20:59:45 +00004382 if (__comp(*__m, __value_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004383 {
4384 __first = ++__m;
4385 __len -= __l2 + 1;
4386 }
Howard Hinnantbf074022011-10-22 20:59:45 +00004387 else if (__comp(__value_, *__m))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004388 {
4389 __last = __m;
4390 __len = __l2;
4391 }
4392 else
4393 {
4394 _ForwardIterator __mp1 = __m;
4395 return pair<_ForwardIterator, _ForwardIterator>
4396 (
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004397 _VSTD::__lower_bound<_Compare>(__first, __m, __value_, __comp),
4398 _VSTD::__upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004399 );
4400 }
4401 }
4402 return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
4403}
4404
4405template <class _ForwardIterator, class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00004406_LIBCPP_NODISCARD_EXT inline
4407_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004408pair<_ForwardIterator, _ForwardIterator>
Howard Hinnantbf074022011-10-22 20:59:45 +00004409equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004410{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00004411 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004412 return _VSTD::__equal_range<_Comp_ref>(__first, __last, __value_, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004413}
4414
4415template <class _ForwardIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00004416_LIBCPP_NODISCARD_EXT inline
4417_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004418pair<_ForwardIterator, _ForwardIterator>
Howard Hinnantbf074022011-10-22 20:59:45 +00004419equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004420{
Howard Hinnantbf074022011-10-22 20:59:45 +00004421 return _VSTD::equal_range(__first, __last, __value_,
Howard Hinnantc51e1022010-05-11 19:42:16 +00004422 __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
4423}
4424
4425// binary_search
4426
4427template <class _Compare, class _ForwardIterator, class _Tp>
Marshall Clowe00916c2018-01-16 02:34:41 +00004428inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004429bool
Howard Hinnantbf074022011-10-22 20:59:45 +00004430__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004431{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004432 __first = _VSTD::__lower_bound<_Compare>(__first, __last, __value_, __comp);
Howard Hinnantbf074022011-10-22 20:59:45 +00004433 return __first != __last && !__comp(__value_, *__first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004434}
4435
4436template <class _ForwardIterator, class _Tp, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00004437_LIBCPP_NODISCARD_EXT inline
4438_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004439bool
Howard Hinnantbf074022011-10-22 20:59:45 +00004440binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004441{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00004442 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004443 return _VSTD::__binary_search<_Comp_ref>(__first, __last, __value_, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004444}
4445
4446template <class _ForwardIterator, class _Tp>
Nico Weber471b10a2019-04-03 18:13:08 +00004447_LIBCPP_NODISCARD_EXT inline
4448_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004449bool
Howard Hinnantbf074022011-10-22 20:59:45 +00004450binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004451{
Howard Hinnantbf074022011-10-22 20:59:45 +00004452 return _VSTD::binary_search(__first, __last, __value_,
Howard Hinnantc51e1022010-05-11 19:42:16 +00004453 __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
4454}
4455
4456// merge
4457
4458template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
Nicholas-Baron7fd82722020-09-14 16:37:41 -04004459_LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004460_OutputIterator
4461__merge(_InputIterator1 __first1, _InputIterator1 __last1,
4462 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
4463{
4464 for (; __first1 != __last1; ++__result)
4465 {
4466 if (__first2 == __last2)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004467 return _VSTD::copy(__first1, __last1, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004468 if (__comp(*__first2, *__first1))
4469 {
4470 *__result = *__first2;
4471 ++__first2;
4472 }
4473 else
4474 {
4475 *__result = *__first1;
4476 ++__first1;
4477 }
4478 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004479 return _VSTD::copy(__first2, __last2, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004480}
4481
4482template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
Nicholas-Baron7fd82722020-09-14 16:37:41 -04004483inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004484_OutputIterator
4485merge(_InputIterator1 __first1, _InputIterator1 __last1,
4486 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
4487{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00004488 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004489 return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004490}
4491
4492template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
Nicholas-Baron7fd82722020-09-14 16:37:41 -04004493inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004494_OutputIterator
4495merge(_InputIterator1 __first1, _InputIterator1 __last1,
4496 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
4497{
4498 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
4499 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
Marshall Clowf913beb2019-08-20 22:23:35 +00004500 return _VSTD::merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00004501}
4502
4503// inplace_merge
4504
Marshall Clow1bc51102015-07-29 16:25:45 +00004505template <class _Compare, class _InputIterator1, class _InputIterator2,
4506 class _OutputIterator>
4507void __half_inplace_merge(_InputIterator1 __first1, _InputIterator1 __last1,
4508 _InputIterator2 __first2, _InputIterator2 __last2,
4509 _OutputIterator __result, _Compare __comp)
4510{
4511 for (; __first1 != __last1; ++__result)
4512 {
4513 if (__first2 == __last2)
4514 {
4515 _VSTD::move(__first1, __last1, __result);
4516 return;
4517 }
4518
4519 if (__comp(*__first2, *__first1))
4520 {
4521 *__result = _VSTD::move(*__first2);
4522 ++__first2;
4523 }
4524 else
4525 {
4526 *__result = _VSTD::move(*__first1);
4527 ++__first1;
4528 }
4529 }
4530 // __first2 through __last2 are already in the right spot.
4531}
4532
Howard Hinnantc51e1022010-05-11 19:42:16 +00004533template <class _Compare, class _BidirectionalIterator>
4534void
4535__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
4536 _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
4537 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
4538 typename iterator_traits<_BidirectionalIterator>::value_type* __buff)
4539{
4540 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004541 __destruct_n __d(0);
4542 unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
4543 if (__len1 <= __len2)
4544 {
4545 value_type* __p = __buff;
Bruce Mitchener170d8972020-11-24 12:53:53 -05004546 for (_BidirectionalIterator __i = __first; __i != __middle; __d.template __incr<value_type>(), (void) ++__i, (void) ++__p)
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004547 ::new ((void*)__p) value_type(_VSTD::move(*__i));
Arthur O'Dwyer2f0c3302020-12-18 15:11:51 -05004548 _VSTD::__half_inplace_merge<_Compare>(__buff, __p, __middle, __last, __first, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004549 }
4550 else
4551 {
4552 value_type* __p = __buff;
Bruce Mitchener170d8972020-11-24 12:53:53 -05004553 for (_BidirectionalIterator __i = __middle; __i != __last; __d.template __incr<value_type>(), (void) ++__i, (void) ++__p)
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004554 ::new ((void*)__p) value_type(_VSTD::move(*__i));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004555 typedef reverse_iterator<_BidirectionalIterator> _RBi;
4556 typedef reverse_iterator<value_type*> _Rv;
Arthur O'Dwyer2f0c3302020-12-18 15:11:51 -05004557 typedef __invert<_Compare> _Inverted;
4558 _VSTD::__half_inplace_merge<_Inverted>(_Rv(__p), _Rv(__buff),
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004559 _RBi(__middle), _RBi(__first),
Arthur O'Dwyer2f0c3302020-12-18 15:11:51 -05004560 _RBi(__last), _Inverted(__comp));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004561 }
4562}
4563
4564template <class _Compare, class _BidirectionalIterator>
4565void
4566__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
4567 _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
4568 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
4569 typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size)
4570{
Howard Hinnantc51e1022010-05-11 19:42:16 +00004571 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
4572 while (true)
4573 {
4574 // if __middle == __last, we're done
4575 if (__len2 == 0)
4576 return;
Marshall Clow8eff8232015-02-02 16:44:11 +00004577 if (__len1 <= __buff_size || __len2 <= __buff_size)
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004578 return _VSTD::__buffered_inplace_merge<_Compare>
Marshall Clow8eff8232015-02-02 16:44:11 +00004579 (__first, __middle, __last, __comp, __len1, __len2, __buff);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004580 // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0
Eric Fiseliera09a3b42014-10-27 19:28:20 +00004581 for (; true; ++__first, (void) --__len1)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004582 {
4583 if (__len1 == 0)
4584 return;
4585 if (__comp(*__middle, *__first))
4586 break;
4587 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00004588 // __first < __middle < __last
4589 // *__first > *__middle
4590 // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that
4591 // all elements in:
4592 // [__first, __m1) <= [__middle, __m2)
4593 // [__middle, __m2) < [__m1, __middle)
4594 // [__m1, __middle) <= [__m2, __last)
4595 // and __m1 or __m2 is in the middle of its range
4596 _BidirectionalIterator __m1; // "median" of [__first, __middle)
4597 _BidirectionalIterator __m2; // "median" of [__middle, __last)
4598 difference_type __len11; // distance(__first, __m1)
4599 difference_type __len21; // distance(__middle, __m2)
4600 // binary search smaller range
4601 if (__len1 < __len2)
4602 { // __len >= 1, __len2 >= 2
4603 __len21 = __len2 / 2;
4604 __m2 = __middle;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004605 _VSTD::advance(__m2, __len21);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004606 __m1 = _VSTD::__upper_bound<_Compare>(__first, __middle, *__m2, __comp);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004607 __len11 = _VSTD::distance(__first, __m1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004608 }
4609 else
4610 {
4611 if (__len1 == 1)
4612 { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1
4613 // It is known *__first > *__middle
4614 swap(*__first, *__middle);
4615 return;
4616 }
4617 // __len1 >= 2, __len2 >= 1
4618 __len11 = __len1 / 2;
4619 __m1 = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004620 _VSTD::advance(__m1, __len11);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004621 __m2 = _VSTD::__lower_bound<_Compare>(__middle, __last, *__m1, __comp);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004622 __len21 = _VSTD::distance(__middle, __m2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004623 }
4624 difference_type __len12 = __len1 - __len11; // distance(__m1, __middle)
4625 difference_type __len22 = __len2 - __len21; // distance(__m2, __last)
4626 // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
4627 // swap middle two partitions
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004628 __middle = _VSTD::rotate(__m1, __middle, __m2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004629 // __len12 and __len21 now have swapped meanings
Arthur O'Dwyerdf5df562020-12-12 11:57:32 -05004630 // merge smaller range with recursive call and larger with tail recursion elimination
Howard Hinnantc51e1022010-05-11 19:42:16 +00004631 if (__len11 + __len21 < __len12 + __len22)
4632 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004633 _VSTD::__inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
4634// _VSTD::__inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004635 __first = __middle;
4636 __middle = __m2;
4637 __len1 = __len12;
4638 __len2 = __len22;
4639 }
4640 else
4641 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004642 _VSTD::__inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
4643// _VSTD::__inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004644 __last = __middle;
4645 __middle = __m1;
4646 __len1 = __len11;
4647 __len2 = __len21;
4648 }
4649 }
4650}
4651
Howard Hinnantc51e1022010-05-11 19:42:16 +00004652template <class _BidirectionalIterator, class _Compare>
4653inline _LIBCPP_INLINE_VISIBILITY
4654void
4655inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
4656 _Compare __comp)
4657{
4658 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
4659 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004660 difference_type __len1 = _VSTD::distance(__first, __middle);
4661 difference_type __len2 = _VSTD::distance(__middle, __last);
4662 difference_type __buf_size = _VSTD::min(__len1, __len2);
Marshall Clow488f19f2015-02-02 17:35:53 +00004663 pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
4664 unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first);
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00004665 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004666 return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
Howard Hinnantc51e1022010-05-11 19:42:16 +00004667 __buf.first, __buf.second);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004668}
4669
4670template <class _BidirectionalIterator>
4671inline _LIBCPP_INLINE_VISIBILITY
4672void
4673inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
4674{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004675 _VSTD::inplace_merge(__first, __middle, __last,
Howard Hinnantc51e1022010-05-11 19:42:16 +00004676 __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
4677}
4678
4679// stable_sort
4680
4681template <class _Compare, class _InputIterator1, class _InputIterator2>
4682void
4683__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
4684 _InputIterator2 __first2, _InputIterator2 __last2,
4685 typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp)
4686{
4687 typedef typename iterator_traits<_InputIterator1>::value_type value_type;
4688 __destruct_n __d(0);
4689 unique_ptr<value_type, __destruct_n&> __h(__result, __d);
4690 for (; true; ++__result)
4691 {
4692 if (__first1 == __last1)
4693 {
Bruce Mitchener170d8972020-11-24 12:53:53 -05004694 for (; __first2 != __last2; ++__first2, ++__result, (void)__d.template __incr<value_type>())
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004695 ::new ((void*)__result) value_type(_VSTD::move(*__first2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004696 __h.release();
4697 return;
4698 }
4699 if (__first2 == __last2)
4700 {
Bruce Mitchener170d8972020-11-24 12:53:53 -05004701 for (; __first1 != __last1; ++__first1, ++__result, (void)__d.template __incr<value_type>())
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004702 ::new ((void*)__result) value_type(_VSTD::move(*__first1));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004703 __h.release();
4704 return;
4705 }
4706 if (__comp(*__first2, *__first1))
4707 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004708 ::new ((void*)__result) value_type(_VSTD::move(*__first2));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004709 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004710 ++__first2;
4711 }
4712 else
4713 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004714 ::new ((void*)__result) value_type(_VSTD::move(*__first1));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004715 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004716 ++__first1;
4717 }
4718 }
4719}
4720
4721template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
4722void
4723__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
4724 _InputIterator2 __first2, _InputIterator2 __last2,
4725 _OutputIterator __result, _Compare __comp)
4726{
4727 for (; __first1 != __last1; ++__result)
4728 {
4729 if (__first2 == __last2)
4730 {
Marshall Clow0d332012019-08-20 21:31:51 +00004731 for (; __first1 != __last1; ++__first1, (void) ++__result)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004732 *__result = _VSTD::move(*__first1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004733 return;
4734 }
4735 if (__comp(*__first2, *__first1))
4736 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004737 *__result = _VSTD::move(*__first2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004738 ++__first2;
4739 }
4740 else
4741 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004742 *__result = _VSTD::move(*__first1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004743 ++__first1;
4744 }
4745 }
Marshall Clow0d332012019-08-20 21:31:51 +00004746 for (; __first2 != __last2; ++__first2, (void) ++__result)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004747 *__result = _VSTD::move(*__first2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004748}
4749
4750template <class _Compare, class _RandomAccessIterator>
4751void
4752__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4753 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4754 typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size);
4755
4756template <class _Compare, class _RandomAccessIterator>
4757void
4758__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp,
4759 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4760 typename iterator_traits<_RandomAccessIterator>::value_type* __first2)
4761{
4762 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4763 switch (__len)
4764 {
4765 case 0:
4766 return;
4767 case 1:
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004768 ::new ((void*)__first2) value_type(_VSTD::move(*__first1));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004769 return;
4770 case 2:
Marshall Clow32043ac2018-02-06 18:58:05 +00004771 __destruct_n __d(0);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004772 unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
Marshall Clow32043ac2018-02-06 18:58:05 +00004773 if (__comp(*--__last1, *__first1))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004774 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004775 ::new ((void*)__first2) value_type(_VSTD::move(*__last1));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004776 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004777 ++__first2;
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004778 ::new ((void*)__first2) value_type(_VSTD::move(*__first1));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004779 }
4780 else
4781 {
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004782 ::new ((void*)__first2) value_type(_VSTD::move(*__first1));
Bruce Mitchener170d8972020-11-24 12:53:53 -05004783 __d.template __incr<value_type>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00004784 ++__first2;
Arthur O'Dwyer0c4472a2020-12-11 20:30:28 -05004785 ::new ((void*)__first2) value_type(_VSTD::move(*__last1));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004786 }
4787 __h2.release();
4788 return;
4789 }
4790 if (__len <= 8)
4791 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004792 _VSTD::__insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004793 return;
4794 }
4795 typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
4796 _RandomAccessIterator __m = __first1 + __l2;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004797 _VSTD::__stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2);
4798 _VSTD::__stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
4799 _VSTD::__merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004800}
4801
4802template <class _Tp>
4803struct __stable_sort_switch
4804{
Howard Hinnanta9a897e2010-11-19 22:17:28 +00004805 static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004806};
4807
4808template <class _Compare, class _RandomAccessIterator>
4809void
4810__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4811 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4812 typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size)
4813{
4814 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4815 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4816 switch (__len)
4817 {
4818 case 0:
4819 case 1:
4820 return;
4821 case 2:
4822 if (__comp(*--__last, *__first))
4823 swap(*__first, *__last);
4824 return;
4825 }
4826 if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value))
4827 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004828 _VSTD::__insertion_sort<_Compare>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004829 return;
4830 }
4831 typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
4832 _RandomAccessIterator __m = __first + __l2;
4833 if (__len <= __buff_size)
4834 {
4835 __destruct_n __d(0);
4836 unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004837 _VSTD::__stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff);
Bruce Mitchener170d8972020-11-24 12:53:53 -05004838 __d.__set(__l2, (value_type*)nullptr);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004839 _VSTD::__stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
Bruce Mitchener170d8972020-11-24 12:53:53 -05004840 __d.__set(__len, (value_type*)nullptr);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004841 _VSTD::__merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
4842// _VSTD::__merge<_Compare>(move_iterator<value_type*>(__buff),
4843// move_iterator<value_type*>(__buff + __l2),
4844// move_iterator<_RandomAccessIterator>(__buff + __l2),
4845// move_iterator<_RandomAccessIterator>(__buff + __len),
4846// __first, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004847 return;
4848 }
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004849 _VSTD::__stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
4850 _VSTD::__stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
4851 _VSTD::__inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004852}
4853
4854template <class _RandomAccessIterator, class _Compare>
4855inline _LIBCPP_INLINE_VISIBILITY
4856void
4857stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4858{
4859 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4860 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4861 difference_type __len = __last - __first;
4862 pair<value_type*, ptrdiff_t> __buf(0, 0);
4863 unique_ptr<value_type, __return_temporary_buffer> __h;
4864 if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
4865 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004866 __buf = _VSTD::get_temporary_buffer<value_type>(__len);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004867 __h.reset(__buf.first);
4868 }
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00004869 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004870 _VSTD::__stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004871}
4872
4873template <class _RandomAccessIterator>
4874inline _LIBCPP_INLINE_VISIBILITY
4875void
4876stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
4877{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004878 _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00004879}
4880
4881// is_heap_until
4882
4883template <class _RandomAccessIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00004884_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00004885is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4886{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004887 typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004888 difference_type __len = __last - __first;
4889 difference_type __p = 0;
4890 difference_type __c = 1;
4891 _RandomAccessIterator __pp = __first;
4892 while (__c < __len)
4893 {
4894 _RandomAccessIterator __cp = __first + __c;
4895 if (__comp(*__pp, *__cp))
4896 return __cp;
4897 ++__c;
4898 ++__cp;
4899 if (__c == __len)
4900 return __last;
4901 if (__comp(*__pp, *__cp))
4902 return __cp;
4903 ++__p;
4904 ++__pp;
4905 __c = 2 * __p + 1;
4906 }
4907 return __last;
4908}
4909
Howard Hinnant3b6579a2010-08-22 00:02:43 +00004910template<class _RandomAccessIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00004911_LIBCPP_NODISCARD_EXT inline
4912_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004913_RandomAccessIterator
4914is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
4915{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004916 return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00004917}
4918
4919// is_heap
4920
4921template <class _RandomAccessIterator, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00004922_LIBCPP_NODISCARD_EXT inline
4923_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004924bool
4925is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4926{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004927 return _VSTD::is_heap_until(__first, __last, __comp) == __last;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004928}
4929
Howard Hinnant3b6579a2010-08-22 00:02:43 +00004930template<class _RandomAccessIterator>
Nico Weber471b10a2019-04-03 18:13:08 +00004931_LIBCPP_NODISCARD_EXT inline
4932_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004933bool
4934is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
4935{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004936 return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00004937}
4938
4939// push_heap
4940
4941template <class _Compare, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05004942_LIBCPP_CONSTEXPR_AFTER_CXX11 void
David Majnemer4468d562014-07-22 06:07:09 +00004943__sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4944 typename iterator_traits<_RandomAccessIterator>::difference_type __len)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004945{
Howard Hinnantc51e1022010-05-11 19:42:16 +00004946 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4947 if (__len > 1)
4948 {
4949 __len = (__len - 2) / 2;
4950 _RandomAccessIterator __ptr = __first + __len;
4951 if (__comp(*__ptr, *--__last))
4952 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004953 value_type __t(_VSTD::move(*__last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004954 do
4955 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004956 *__last = _VSTD::move(*__ptr);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004957 __last = __ptr;
4958 if (__len == 0)
4959 break;
4960 __len = (__len - 1) / 2;
4961 __ptr = __first + __len;
4962 } while (__comp(*__ptr, __t));
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004963 *__last = _VSTD::move(__t);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004964 }
4965 }
4966}
4967
4968template <class _RandomAccessIterator, class _Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05004969inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004970void
4971push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4972{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00004973 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05004974 _VSTD::__sift_up<_Comp_ref>(__first, __last, __comp, __last - __first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004975}
4976
4977template <class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05004978inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00004979void
4980push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
4981{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004982 _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00004983}
4984
4985// pop_heap
4986
4987template <class _Compare, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05004988_LIBCPP_CONSTEXPR_AFTER_CXX11 void
Eric Fiselier6003c772016-12-23 23:37:52 +00004989__sift_down(_RandomAccessIterator __first, _RandomAccessIterator /*__last*/,
4990 _Compare __comp,
David Majnemer4468d562014-07-22 06:07:09 +00004991 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4992 _RandomAccessIterator __start)
4993{
4994 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4995 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4996 // left-child of __start is at 2 * __start + 1
4997 // right-child of __start is at 2 * __start + 2
4998 difference_type __child = __start - __first;
4999
5000 if (__len < 2 || (__len - 2) / 2 < __child)
5001 return;
5002
5003 __child = 2 * __child + 1;
5004 _RandomAccessIterator __child_i = __first + __child;
5005
5006 if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + 1))) {
5007 // right-child exists and is greater than left-child
5008 ++__child_i;
5009 ++__child;
5010 }
5011
5012 // check if we are in heap-order
5013 if (__comp(*__child_i, *__start))
5014 // we are, __start is larger than it's largest child
5015 return;
5016
5017 value_type __top(_VSTD::move(*__start));
5018 do
5019 {
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005020 // we are not in heap-order, swap the parent with its largest child
David Majnemer4468d562014-07-22 06:07:09 +00005021 *__start = _VSTD::move(*__child_i);
5022 __start = __child_i;
5023
5024 if ((__len - 2) / 2 < __child)
5025 break;
5026
5027 // recompute the child based off of the updated parent
5028 __child = 2 * __child + 1;
5029 __child_i = __first + __child;
5030
5031 if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + 1))) {
5032 // right-child exists and is greater than left-child
5033 ++__child_i;
5034 ++__child;
5035 }
5036
5037 // check if we are in heap-order
5038 } while (!__comp(*__child_i, __top));
5039 *__start = _VSTD::move(__top);
5040}
5041
5042template <class _Compare, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005043inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005044void
5045__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
5046 typename iterator_traits<_RandomAccessIterator>::difference_type __len)
5047{
5048 if (__len > 1)
5049 {
5050 swap(*__first, *--__last);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005051 _VSTD::__sift_down<_Compare>(__first, __last, __comp, __len - 1, __first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005052 }
5053}
5054
5055template <class _RandomAccessIterator, class _Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005056inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005057void
5058pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5059{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005060 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005061 _VSTD::__pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005062}
5063
5064template <class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005065inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005066void
5067pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
5068{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005069 _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00005070}
5071
5072// make_heap
5073
5074template <class _Compare, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005075_LIBCPP_CONSTEXPR_AFTER_CXX11 void
Howard Hinnantc51e1022010-05-11 19:42:16 +00005076__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5077{
5078 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
5079 difference_type __n = __last - __first;
5080 if (__n > 1)
5081 {
David Majnemer4468d562014-07-22 06:07:09 +00005082 // start from the first parent, there is no need to consider children
5083 for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start)
5084 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005085 _VSTD::__sift_down<_Compare>(__first, __last, __comp, __n, __first + __start);
David Majnemer4468d562014-07-22 06:07:09 +00005086 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00005087 }
5088}
5089
5090template <class _RandomAccessIterator, class _Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005091inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005092void
5093make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5094{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005095 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005096 _VSTD::__make_heap<_Comp_ref>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005097}
5098
5099template <class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005100inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005101void
5102make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
5103{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005104 _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00005105}
5106
5107// sort_heap
5108
5109template <class _Compare, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005110_LIBCPP_CONSTEXPR_AFTER_CXX17 void
Howard Hinnantc51e1022010-05-11 19:42:16 +00005111__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5112{
5113 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
Marshall Clow0d332012019-08-20 21:31:51 +00005114 for (difference_type __n = __last - __first; __n > 1; --__last, (void) --__n)
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005115 _VSTD::__pop_heap<_Compare>(__first, __last, __comp, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005116}
5117
5118template <class _RandomAccessIterator, class _Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005119inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005120void
5121sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5122{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005123 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005124 _VSTD::__sort_heap<_Comp_ref>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005125}
5126
5127template <class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005128inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005129void
5130sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
5131{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005132 _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00005133}
5134
5135// partial_sort
5136
5137template <class _Compare, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005138_LIBCPP_CONSTEXPR_AFTER_CXX17 void
Howard Hinnantc51e1022010-05-11 19:42:16 +00005139__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
5140 _Compare __comp)
5141{
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005142 _VSTD::__make_heap<_Compare>(__first, __middle, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005143 typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first;
5144 for (_RandomAccessIterator __i = __middle; __i != __last; ++__i)
5145 {
5146 if (__comp(*__i, *__first))
5147 {
5148 swap(*__i, *__first);
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005149 _VSTD::__sift_down<_Compare>(__first, __middle, __comp, __len, __first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005150 }
5151 }
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005152 _VSTD::__sort_heap<_Compare>(__first, __middle, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005153}
5154
5155template <class _RandomAccessIterator, class _Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005156inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005157void
5158partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
5159 _Compare __comp)
5160{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005161 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005162 _VSTD::__partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005163}
5164
5165template <class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005166inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005167void
5168partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
5169{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005170 _VSTD::partial_sort(__first, __middle, __last,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005171 __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5172}
5173
5174// partial_sort_copy
5175
5176template <class _Compare, class _InputIterator, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005177_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00005178__partial_sort_copy(_InputIterator __first, _InputIterator __last,
5179 _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
5180{
5181 _RandomAccessIterator __r = __result_first;
5182 if (__r != __result_last)
5183 {
Marshall Clow0d332012019-08-20 21:31:51 +00005184 for (; __first != __last && __r != __result_last; ++__first, (void) ++__r)
Howard Hinnantc51e1022010-05-11 19:42:16 +00005185 *__r = *__first;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005186 _VSTD::__make_heap<_Compare>(__result_first, __r, __comp);
David Majnemer4468d562014-07-22 06:07:09 +00005187 typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005188 for (; __first != __last; ++__first)
5189 if (__comp(*__first, *__result_first))
5190 {
5191 *__result_first = *__first;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005192 _VSTD::__sift_down<_Compare>(__result_first, __r, __comp, __len, __result_first);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005193 }
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005194 _VSTD::__sort_heap<_Compare>(__result_first, __r, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005195 }
5196 return __r;
5197}
5198
5199template <class _InputIterator, class _RandomAccessIterator, class _Compare>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005200inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005201_RandomAccessIterator
5202partial_sort_copy(_InputIterator __first, _InputIterator __last,
5203 _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
5204{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005205 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005206 return _VSTD::__partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005207}
5208
5209template <class _InputIterator, class _RandomAccessIterator>
Arthur O'Dwyer2dfea5d2020-12-17 00:26:18 -05005210inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005211_RandomAccessIterator
5212partial_sort_copy(_InputIterator __first, _InputIterator __last,
5213 _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
5214{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005215 return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005216 __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5217}
5218
5219// nth_element
5220
5221template <class _Compare, class _RandomAccessIterator>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005222void
Howard Hinnantc51e1022010-05-11 19:42:16 +00005223__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
5224{
5225 // _Compare is known to be a reference type
5226 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
5227 const difference_type __limit = 7;
5228 while (true)
5229 {
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005230 __restart:
Howard Hinnant2fa038c2011-12-29 17:45:35 +00005231 if (__nth == __last)
5232 return;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005233 difference_type __len = __last - __first;
5234 switch (__len)
5235 {
5236 case 0:
5237 case 1:
5238 return;
5239 case 2:
5240 if (__comp(*--__last, *__first))
5241 swap(*__first, *__last);
5242 return;
5243 case 3:
5244 {
5245 _RandomAccessIterator __m = __first;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005246 _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005247 return;
5248 }
5249 }
5250 if (__len <= __limit)
5251 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005252 _VSTD::__selection_sort<_Compare>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005253 return;
5254 }
5255 // __len > __limit >= 3
5256 _RandomAccessIterator __m = __first + __len/2;
5257 _RandomAccessIterator __lm1 = __last;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005258 unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005259 // *__m is median
5260 // partition [__first, __m) < *__m and *__m <= [__m, __last)
5261 // (this inhibits tossing elements equivalent to __m around unnecessarily)
5262 _RandomAccessIterator __i = __first;
5263 _RandomAccessIterator __j = __lm1;
5264 // j points beyond range to be tested, *__lm1 is known to be <= *__m
5265 // The search going up is known to be guarded but the search coming down isn't.
5266 // Prime the downward search with a guard.
5267 if (!__comp(*__i, *__m)) // if *__first == *__m
5268 {
5269 // *__first == *__m, *__first doesn't go in first part
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005270 // manually guard downward moving __j against __i
5271 while (true)
5272 {
5273 if (__i == --__j)
5274 {
5275 // *__first == *__m, *__m <= all other elements
5276 // Partition instead into [__first, __i) == *__first and *__first < [__i, __last)
5277 ++__i; // __first + 1
5278 __j = __last;
5279 if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1)
5280 {
5281 while (true)
5282 {
5283 if (__i == __j)
5284 return; // [__first, __last) all equivalent elements
5285 if (__comp(*__first, *__i))
5286 {
5287 swap(*__i, *__j);
5288 ++__n_swaps;
5289 ++__i;
5290 break;
5291 }
5292 ++__i;
5293 }
5294 }
5295 // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
5296 if (__i == __j)
5297 return;
5298 while (true)
5299 {
5300 while (!__comp(*__first, *__i))
5301 ++__i;
5302 while (__comp(*__first, *--__j))
5303 ;
5304 if (__i >= __j)
5305 break;
5306 swap(*__i, *__j);
5307 ++__n_swaps;
5308 ++__i;
5309 }
5310 // [__first, __i) == *__first and *__first < [__i, __last)
5311 // The first part is sorted,
5312 if (__nth < __i)
5313 return;
5314 // __nth_element the second part
5315 // _VSTD::__nth_element<_Compare>(__i, __nth, __last, __comp);
5316 __first = __i;
5317 goto __restart;
5318 }
5319 if (__comp(*__j, *__m))
5320 {
5321 swap(*__i, *__j);
5322 ++__n_swaps;
5323 break; // found guard for downward moving __j, now use unguarded partition
5324 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00005325 }
5326 }
5327 ++__i;
5328 // j points beyond range to be tested, *__lm1 is known to be <= *__m
5329 // if not yet partitioned...
5330 if (__i < __j)
5331 {
5332 // known that *(__i - 1) < *__m
5333 while (true)
5334 {
5335 // __m still guards upward moving __i
5336 while (__comp(*__i, *__m))
5337 ++__i;
5338 // It is now known that a guard exists for downward moving __j
5339 while (!__comp(*--__j, *__m))
5340 ;
5341 if (__i >= __j)
5342 break;
5343 swap(*__i, *__j);
5344 ++__n_swaps;
5345 // It is known that __m != __j
5346 // If __m just moved, follow it
5347 if (__m == __i)
5348 __m = __j;
5349 ++__i;
5350 }
5351 }
5352 // [__first, __i) < *__m and *__m <= [__i, __last)
5353 if (__i != __m && __comp(*__m, *__i))
5354 {
5355 swap(*__i, *__m);
5356 ++__n_swaps;
5357 }
5358 // [__first, __i) < *__i and *__i <= [__i+1, __last)
5359 if (__nth == __i)
5360 return;
5361 if (__n_swaps == 0)
5362 {
5363 // We were given a perfectly partitioned sequence. Coincidence?
5364 if (__nth < __i)
5365 {
5366 // Check for [__first, __i) already sorted
5367 __j = __m = __first;
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005368 while (++__j != __i)
Howard Hinnantc51e1022010-05-11 19:42:16 +00005369 {
5370 if (__comp(*__j, *__m))
5371 // not yet sorted, so sort
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005372 goto not_sorted;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005373 __m = __j;
5374 }
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005375 // [__first, __i) sorted
5376 return;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005377 }
5378 else
5379 {
5380 // Check for [__i, __last) already sorted
5381 __j = __m = __i;
5382 while (++__j != __last)
5383 {
5384 if (__comp(*__j, *__m))
5385 // not yet sorted, so sort
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005386 goto not_sorted;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005387 __m = __j;
5388 }
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005389 // [__i, __last) sorted
5390 return;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005391 }
5392 }
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005393not_sorted:
Howard Hinnantc51e1022010-05-11 19:42:16 +00005394 // __nth_element on range containing __nth
5395 if (__nth < __i)
5396 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005397 // _VSTD::__nth_element<_Compare>(__first, __nth, __i, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005398 __last = __i;
5399 }
5400 else
5401 {
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005402 // _VSTD::__nth_element<_Compare>(__i+1, __nth, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005403 __first = ++__i;
5404 }
5405 }
5406}
5407
5408template <class _RandomAccessIterator, class _Compare>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005409inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00005410void
5411nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
5412{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005413 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005414 _VSTD::__nth_element<_Comp_ref>(__first, __nth, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005415}
5416
5417template <class _RandomAccessIterator>
Jordan Rupprecht0dcd8eb2021-02-04 13:56:41 -08005418inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00005419void
5420nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)
5421{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005422 _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
Howard Hinnantc51e1022010-05-11 19:42:16 +00005423}
5424
Arthur O'Dwyer1bb0f672020-12-20 15:21:42 -05005425// sort
5426
5427template <class _RandomAccessIterator, class _Compare>
5428inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5429void
5430sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5431{
5432 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5433 if (__libcpp_is_constant_evaluated()) {
5434 _VSTD::__partial_sort<_Comp_ref>(__first, __last, __last, _Comp_ref(__comp));
5435 } else {
5436 _VSTD::__sort<_Comp_ref>(_VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _Comp_ref(__comp));
5437 }
5438}
5439
5440template <class _RandomAccessIterator>
5441inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5442void
5443sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
5444{
5445 _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5446}
5447
Howard Hinnantc51e1022010-05-11 19:42:16 +00005448// includes
5449
5450template <class _Compare, class _InputIterator1, class _InputIterator2>
Marshall Clowc0b7f972018-01-22 23:10:40 +00005451_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00005452__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
5453 _Compare __comp)
5454{
5455 for (; __first2 != __last2; ++__first1)
5456 {
5457 if (__first1 == __last1 || __comp(*__first2, *__first1))
5458 return false;
5459 if (!__comp(*__first1, *__first2))
5460 ++__first2;
5461 }
5462 return true;
5463}
5464
5465template <class _InputIterator1, class _InputIterator2, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00005466_LIBCPP_NODISCARD_EXT inline
5467_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005468bool
5469includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
5470 _Compare __comp)
5471{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005472 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005473 return _VSTD::__includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005474}
5475
5476template <class _InputIterator1, class _InputIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00005477_LIBCPP_NODISCARD_EXT inline
5478_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005479bool
5480includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
5481{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005482 return _VSTD::includes(__first1, __last1, __first2, __last2,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005483 __less<typename iterator_traits<_InputIterator1>::value_type,
5484 typename iterator_traits<_InputIterator2>::value_type>());
5485}
5486
5487// set_union
5488
5489template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005490_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00005491__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5492 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5493{
5494 for (; __first1 != __last1; ++__result)
5495 {
5496 if (__first2 == __last2)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005497 return _VSTD::copy(__first1, __last1, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005498 if (__comp(*__first2, *__first1))
5499 {
5500 *__result = *__first2;
5501 ++__first2;
5502 }
5503 else
5504 {
Howard Hinnantc51e1022010-05-11 19:42:16 +00005505 if (!__comp(*__first1, *__first2))
5506 ++__first2;
Marshall Clowb4687412017-10-30 15:50:00 +00005507 *__result = *__first1;
Howard Hinnantc51e1022010-05-11 19:42:16 +00005508 ++__first1;
5509 }
5510 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005511 return _VSTD::copy(__first2, __last2, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005512}
5513
5514template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005515inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005516_OutputIterator
5517set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5518 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5519{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005520 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005521 return _VSTD::__set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005522}
5523
5524template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005525inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005526_OutputIterator
5527set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5528 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5529{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005530 return _VSTD::set_union(__first1, __last1, __first2, __last2, __result,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005531 __less<typename iterator_traits<_InputIterator1>::value_type,
5532 typename iterator_traits<_InputIterator2>::value_type>());
5533}
5534
5535// set_intersection
5536
5537template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
Marshall Clowc0b7f972018-01-22 23:10:40 +00005538_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00005539__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5540 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5541{
5542 while (__first1 != __last1 && __first2 != __last2)
5543 {
5544 if (__comp(*__first1, *__first2))
5545 ++__first1;
5546 else
5547 {
5548 if (!__comp(*__first2, *__first1))
5549 {
5550 *__result = *__first1;
5551 ++__result;
5552 ++__first1;
5553 }
5554 ++__first2;
5555 }
5556 }
5557 return __result;
5558}
5559
5560template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
Marshall Clowc0b7f972018-01-22 23:10:40 +00005561inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005562_OutputIterator
5563set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5564 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5565{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005566 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005567 return _VSTD::__set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005568}
5569
5570template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
Marshall Clowc0b7f972018-01-22 23:10:40 +00005571inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005572_OutputIterator
5573set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5574 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5575{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005576 return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005577 __less<typename iterator_traits<_InputIterator1>::value_type,
5578 typename iterator_traits<_InputIterator2>::value_type>());
5579}
5580
5581// set_difference
5582
5583template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005584_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00005585__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5586 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5587{
5588 while (__first1 != __last1)
5589 {
5590 if (__first2 == __last2)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005591 return _VSTD::copy(__first1, __last1, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005592 if (__comp(*__first1, *__first2))
5593 {
5594 *__result = *__first1;
5595 ++__result;
5596 ++__first1;
5597 }
5598 else
5599 {
5600 if (!__comp(*__first2, *__first1))
5601 ++__first1;
5602 ++__first2;
5603 }
5604 }
5605 return __result;
5606}
5607
5608template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005609inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005610_OutputIterator
5611set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5612 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5613{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005614 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005615 return _VSTD::__set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005616}
5617
5618template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005619inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005620_OutputIterator
5621set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5622 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5623{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005624 return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005625 __less<typename iterator_traits<_InputIterator1>::value_type,
5626 typename iterator_traits<_InputIterator2>::value_type>());
5627}
5628
5629// set_symmetric_difference
5630
5631template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005632_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00005633__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5634 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5635{
5636 while (__first1 != __last1)
5637 {
5638 if (__first2 == __last2)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005639 return _VSTD::copy(__first1, __last1, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005640 if (__comp(*__first1, *__first2))
5641 {
5642 *__result = *__first1;
5643 ++__result;
5644 ++__first1;
5645 }
5646 else
5647 {
5648 if (__comp(*__first2, *__first1))
5649 {
5650 *__result = *__first2;
5651 ++__result;
5652 }
5653 else
5654 ++__first1;
5655 ++__first2;
5656 }
5657 }
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005658 return _VSTD::copy(__first2, __last2, __result);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005659}
5660
5661template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005662inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005663_OutputIterator
5664set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5665 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5666{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005667 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005668 return _VSTD::__set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005669}
5670
5671template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
Arthur O'Dwyer5afc5692020-12-04 13:47:12 -05005672inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005673_OutputIterator
5674set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5675 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5676{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005677 return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005678 __less<typename iterator_traits<_InputIterator1>::value_type,
5679 typename iterator_traits<_InputIterator2>::value_type>());
5680}
5681
5682// lexicographical_compare
5683
5684template <class _Compare, class _InputIterator1, class _InputIterator2>
Marshall Clow5492c8a2018-01-22 20:44:33 +00005685_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00005686__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
5687 _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
5688{
Eric Fiseliera09a3b42014-10-27 19:28:20 +00005689 for (; __first2 != __last2; ++__first1, (void) ++__first2)
Howard Hinnantc51e1022010-05-11 19:42:16 +00005690 {
5691 if (__first1 == __last1 || __comp(*__first1, *__first2))
5692 return true;
5693 if (__comp(*__first2, *__first1))
5694 return false;
5695 }
5696 return false;
5697}
5698
5699template <class _InputIterator1, class _InputIterator2, class _Compare>
Nico Weber471b10a2019-04-03 18:13:08 +00005700_LIBCPP_NODISCARD_EXT inline
5701_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005702bool
5703lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
5704 _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
5705{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005706 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005707 return _VSTD::__lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005708}
5709
5710template <class _InputIterator1, class _InputIterator2>
Nico Weber471b10a2019-04-03 18:13:08 +00005711_LIBCPP_NODISCARD_EXT inline
5712_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005713bool
5714lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
5715 _InputIterator2 __first2, _InputIterator2 __last2)
5716{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005717 return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005718 __less<typename iterator_traits<_InputIterator1>::value_type,
5719 typename iterator_traits<_InputIterator2>::value_type>());
5720}
5721
5722// next_permutation
5723
5724template <class _Compare, class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05005725_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00005726__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5727{
5728 _BidirectionalIterator __i = __last;
5729 if (__first == __last || __first == --__i)
5730 return false;
5731 while (true)
5732 {
5733 _BidirectionalIterator __ip1 = __i;
5734 if (__comp(*--__i, *__ip1))
5735 {
5736 _BidirectionalIterator __j = __last;
5737 while (!__comp(*__i, *--__j))
5738 ;
5739 swap(*__i, *__j);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005740 _VSTD::reverse(__ip1, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005741 return true;
5742 }
5743 if (__i == __first)
5744 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005745 _VSTD::reverse(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005746 return false;
5747 }
5748 }
5749}
5750
5751template <class _BidirectionalIterator, class _Compare>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05005752inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005753bool
5754next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5755{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005756 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005757 return _VSTD::__next_permutation<_Comp_ref>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005758}
5759
5760template <class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05005761inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnant3b6579a2010-08-22 00:02:43 +00005762bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00005763next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
5764{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005765 return _VSTD::next_permutation(__first, __last,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005766 __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
5767}
5768
5769// prev_permutation
5770
5771template <class _Compare, class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05005772_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
Howard Hinnantc51e1022010-05-11 19:42:16 +00005773__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5774{
5775 _BidirectionalIterator __i = __last;
5776 if (__first == __last || __first == --__i)
5777 return false;
5778 while (true)
5779 {
5780 _BidirectionalIterator __ip1 = __i;
5781 if (__comp(*__ip1, *--__i))
5782 {
5783 _BidirectionalIterator __j = __last;
5784 while (!__comp(*--__j, *__i))
5785 ;
5786 swap(*__i, *__j);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005787 _VSTD::reverse(__ip1, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005788 return true;
5789 }
5790 if (__i == __first)
5791 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005792 _VSTD::reverse(__first, __last);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005793 return false;
5794 }
5795 }
5796}
5797
5798template <class _BidirectionalIterator, class _Compare>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05005799inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005800bool
5801prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5802{
Eric Fiselier7ceab7b2019-04-12 05:18:19 +00005803 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
Arthur O'Dwyere75dcfa2020-11-22 13:21:11 -05005804 return _VSTD::__prev_permutation<_Comp_ref>(__first, __last, __comp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00005805}
5806
5807template <class _BidirectionalIterator>
Arthur O'Dwyere50e7472020-12-17 00:01:08 -05005808inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +00005809bool
5810prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
5811{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00005812 return _VSTD::prev_permutation(__first, __last,
Howard Hinnantc51e1022010-05-11 19:42:16 +00005813 __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
5814}
5815
Howard Hinnantc51e1022010-05-11 19:42:16 +00005816_LIBCPP_END_NAMESPACE_STD
5817
Eric Fiselierf4433a32017-05-31 22:07:49 +00005818_LIBCPP_POP_MACROS
5819
Louis Dionne59d0b3c2019-08-05 18:29:14 +00005820#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
Louis Dionned53d8c02019-08-06 21:11:24 +00005821# include <__pstl_algorithm>
Louis Dionne59d0b3c2019-08-05 18:29:14 +00005822#endif
5823
Howard Hinnantc51e1022010-05-11 19:42:16 +00005824#endif // _LIBCPP_ALGORITHM