source: Daodan/MSYS2/mingw32/include/c++/11.2.0/bits/stl_algo.h@ 1181

Last change on this file since 1181 was 1166, checked in by rossy, 3 years ago

Daodan: Replace MinGW build env with an up-to-date MSYS2 env
File size: 209.7 KB
RevLine 
[1166]1// Algorithm implementation -*- C++ -*-
2
3// Copyright (C) 2001-2021 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/*
26 *
27 * Copyright (c) 1994
28 * Hewlett-Packard Company
29 *
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Hewlett-Packard Company makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
37 *
38 *
39 * Copyright (c) 1996
40 * Silicon Graphics Computer Systems, Inc.
41 *
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
49 */
50
51/** @file bits/stl_algo.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{algorithm}
54 */
55
56#ifndef _STL_ALGO_H
57#define _STL_ALGO_H 1
58
59#include <cstdlib> // for rand
60#include <bits/algorithmfwd.h>
61#include <bits/stl_heap.h>
62#include <bits/stl_tempbuf.h> // for _Temporary_buffer
63#include <bits/predefined_ops.h>
64
65#if __cplusplus >= 201103L
66#include <bits/uniform_int_dist.h>
67#endif
68
69// See concept_check.h for the __glibcxx_*_requires macros.
70
71namespace std _GLIBCXX_VISIBILITY(default)
72{
73_GLIBCXX_BEGIN_NAMESPACE_VERSION
74
75 /// Swaps the median value of *__a, *__b and *__c under __comp to *__result
76 template<typename _Iterator, typename _Compare>
77 _GLIBCXX20_CONSTEXPR
78 void
79 __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
80 _Iterator __c, _Compare __comp)
81 {
82 if (__comp(__a, __b))
83 {
84 if (__comp(__b, __c))
85 std::iter_swap(__result, __b);
86 else if (__comp(__a, __c))
87 std::iter_swap(__result, __c);
88 else
89 std::iter_swap(__result, __a);
90 }
91 else if (__comp(__a, __c))
92 std::iter_swap(__result, __a);
93 else if (__comp(__b, __c))
94 std::iter_swap(__result, __c);
95 else
96 std::iter_swap(__result, __b);
97 }
98
99 /// Provided for stable_partition to use.
100 template<typename _InputIterator, typename _Predicate>
101 _GLIBCXX20_CONSTEXPR
102 inline _InputIterator
103 __find_if_not(_InputIterator __first, _InputIterator __last,
104 _Predicate __pred)
105 {
106 return std::__find_if(__first, __last,
107 __gnu_cxx::__ops::__negate(__pred),
108 std::__iterator_category(__first));
109 }
110
111 /// Like find_if_not(), but uses and updates a count of the
112 /// remaining range length instead of comparing against an end
113 /// iterator.
114 template<typename _InputIterator, typename _Predicate, typename _Distance>
115 _GLIBCXX20_CONSTEXPR
116 _InputIterator
117 __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
118 {
119 for (; __len; --__len, (void) ++__first)
120 if (!__pred(__first))
121 break;
122 return __first;
123 }
124
125 // set_difference
126 // set_intersection
127 // set_symmetric_difference
128 // set_union
129 // for_each
130 // find
131 // find_if
132 // find_first_of
133 // adjacent_find
134 // count
135 // count_if
136 // search
137
138 template<typename _ForwardIterator1, typename _ForwardIterator2,
139 typename _BinaryPredicate>
140 _GLIBCXX20_CONSTEXPR
141 _ForwardIterator1
142 __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
143 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
144 _BinaryPredicate __predicate)
145 {
146 // Test for empty ranges
147 if (__first1 == __last1 || __first2 == __last2)
148 return __first1;
149
150 // Test for a pattern of length 1.
151 _ForwardIterator2 __p1(__first2);
152 if (++__p1 == __last2)
153 return std::__find_if(__first1, __last1,
154 __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
155
156 // General case.
157 _ForwardIterator1 __current = __first1;
158
159 for (;;)
160 {
161 __first1 =
162 std::__find_if(__first1, __last1,
163 __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
164
165 if (__first1 == __last1)
166 return __last1;
167
168 _ForwardIterator2 __p = __p1;
169 __current = __first1;
170 if (++__current == __last1)
171 return __last1;
172
173 while (__predicate(__current, __p))
174 {
175 if (++__p == __last2)
176 return __first1;
177 if (++__current == __last1)
178 return __last1;
179 }
180 ++__first1;
181 }
182 return __first1;
183 }
184
185 // search_n
186
187 /**
188 * This is an helper function for search_n overloaded for forward iterators.
189 */
190 template<typename _ForwardIterator, typename _Integer,
191 typename _UnaryPredicate>
192 _GLIBCXX20_CONSTEXPR
193 _ForwardIterator
194 __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
195 _Integer __count, _UnaryPredicate __unary_pred,
196 std::forward_iterator_tag)
197 {
198 __first = std::__find_if(__first, __last, __unary_pred);
199 while (__first != __last)
200 {
201 typename iterator_traits<_ForwardIterator>::difference_type
202 __n = __count;
203 _ForwardIterator __i = __first;
204 ++__i;
205 while (__i != __last && __n != 1 && __unary_pred(__i))
206 {
207 ++__i;
208 --__n;
209 }
210 if (__n == 1)
211 return __first;
212 if (__i == __last)
213 return __last;
214 __first = std::__find_if(++__i, __last, __unary_pred);
215 }
216 return __last;
217 }
218
219 /**
220 * This is an helper function for search_n overloaded for random access
221 * iterators.
222 */
223 template<typename _RandomAccessIter, typename _Integer,
224 typename _UnaryPredicate>
225 _GLIBCXX20_CONSTEXPR
226 _RandomAccessIter
227 __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
228 _Integer __count, _UnaryPredicate __unary_pred,
229 std::random_access_iterator_tag)
230 {
231 typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
232 _DistanceType;
233
234 _DistanceType __tailSize = __last - __first;
235 _DistanceType __remainder = __count;
236
237 while (__remainder <= __tailSize) // the main loop...
238 {
239 __first += __remainder;
240 __tailSize -= __remainder;
241 // __first here is always pointing to one past the last element of
242 // next possible match.
243 _RandomAccessIter __backTrack = __first;
244 while (__unary_pred(--__backTrack))
245 {
246 if (--__remainder == 0)
247 return (__first - __count); // Success
248 }
249 __remainder = __count + 1 - (__first - __backTrack);
250 }
251 return __last; // Failure
252 }
253
254 template<typename _ForwardIterator, typename _Integer,
255 typename _UnaryPredicate>
256 _GLIBCXX20_CONSTEXPR
257 _ForwardIterator
258 __search_n(_ForwardIterator __first, _ForwardIterator __last,
259 _Integer __count,
260 _UnaryPredicate __unary_pred)
261 {
262 if (__count <= 0)
263 return __first;
264
265 if (__count == 1)
266 return std::__find_if(__first, __last, __unary_pred);
267
268 return std::__search_n_aux(__first, __last, __count, __unary_pred,
269 std::__iterator_category(__first));
270 }
271
272 // find_end for forward iterators.
273 template<typename _ForwardIterator1, typename _ForwardIterator2,
274 typename _BinaryPredicate>
275 _GLIBCXX20_CONSTEXPR
276 _ForwardIterator1
277 __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
278 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
279 forward_iterator_tag, forward_iterator_tag,
280 _BinaryPredicate __comp)
281 {
282 if (__first2 == __last2)
283 return __last1;
284
285 _ForwardIterator1 __result = __last1;
286 while (1)
287 {
288 _ForwardIterator1 __new_result
289 = std::__search(__first1, __last1, __first2, __last2, __comp);
290 if (__new_result == __last1)
291 return __result;
292 else
293 {
294 __result = __new_result;
295 __first1 = __new_result;
296 ++__first1;
297 }
298 }
299 }
300
301 // find_end for bidirectional iterators (much faster).
302 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
303 typename _BinaryPredicate>
304 _GLIBCXX20_CONSTEXPR
305 _BidirectionalIterator1
306 __find_end(_BidirectionalIterator1 __first1,
307 _BidirectionalIterator1 __last1,
308 _BidirectionalIterator2 __first2,
309 _BidirectionalIterator2 __last2,
310 bidirectional_iterator_tag, bidirectional_iterator_tag,
311 _BinaryPredicate __comp)
312 {
313 // concept requirements
314 __glibcxx_function_requires(_BidirectionalIteratorConcept<
315 _BidirectionalIterator1>)
316 __glibcxx_function_requires(_BidirectionalIteratorConcept<
317 _BidirectionalIterator2>)
318
319 typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
320 typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
321
322 _RevIterator1 __rlast1(__first1);
323 _RevIterator2 __rlast2(__first2);
324 _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
325 _RevIterator2(__last2), __rlast2,
326 __comp);
327
328 if (__rresult == __rlast1)
329 return __last1;
330 else
331 {
332 _BidirectionalIterator1 __result = __rresult.base();
333 std::advance(__result, -std::distance(__first2, __last2));
334 return __result;
335 }
336 }
337
338 /**
339 * @brief Find last matching subsequence in a sequence.
340 * @ingroup non_mutating_algorithms
341 * @param __first1 Start of range to search.
342 * @param __last1 End of range to search.
343 * @param __first2 Start of sequence to match.
344 * @param __last2 End of sequence to match.
345 * @return The last iterator @c i in the range
346 * @p [__first1,__last1-(__last2-__first2)) such that @c *(i+N) ==
347 * @p *(__first2+N) for each @c N in the range @p
348 * [0,__last2-__first2), or @p __last1 if no such iterator exists.
349 *
350 * Searches the range @p [__first1,__last1) for a sub-sequence that
351 * compares equal value-by-value with the sequence given by @p
352 * [__first2,__last2) and returns an iterator to the __first
353 * element of the sub-sequence, or @p __last1 if the sub-sequence
354 * is not found. The sub-sequence will be the last such
355 * subsequence contained in [__first1,__last1).
356 *
357 * Because the sub-sequence must lie completely within the range @p
358 * [__first1,__last1) it must start at a position less than @p
359 * __last1-(__last2-__first2) where @p __last2-__first2 is the
360 * length of the sub-sequence. This means that the returned
361 * iterator @c i will be in the range @p
362 * [__first1,__last1-(__last2-__first2))
363 */
364 template<typename _ForwardIterator1, typename _ForwardIterator2>
365 _GLIBCXX20_CONSTEXPR
366 inline _ForwardIterator1
367 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
368 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
369 {
370 // concept requirements
371 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
372 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
373 __glibcxx_function_requires(_EqualOpConcept<
374 typename iterator_traits<_ForwardIterator1>::value_type,
375 typename iterator_traits<_ForwardIterator2>::value_type>)
376 __glibcxx_requires_valid_range(__first1, __last1);
377 __glibcxx_requires_valid_range(__first2, __last2);
378
379 return std::__find_end(__first1, __last1, __first2, __last2,
380 std::__iterator_category(__first1),
381 std::__iterator_category(__first2),
382 __gnu_cxx::__ops::__iter_equal_to_iter());
383 }
384
385 /**
386 * @brief Find last matching subsequence in a sequence using a predicate.
387 * @ingroup non_mutating_algorithms
388 * @param __first1 Start of range to search.
389 * @param __last1 End of range to search.
390 * @param __first2 Start of sequence to match.
391 * @param __last2 End of sequence to match.
392 * @param __comp The predicate to use.
393 * @return The last iterator @c i in the range @p
394 * [__first1,__last1-(__last2-__first2)) such that @c
395 * predicate(*(i+N), @p (__first2+N)) is true for each @c N in the
396 * range @p [0,__last2-__first2), or @p __last1 if no such iterator
397 * exists.
398 *
399 * Searches the range @p [__first1,__last1) for a sub-sequence that
400 * compares equal value-by-value with the sequence given by @p
401 * [__first2,__last2) using comp as a predicate and returns an
402 * iterator to the first element of the sub-sequence, or @p __last1
403 * if the sub-sequence is not found. The sub-sequence will be the
404 * last such subsequence contained in [__first,__last1).
405 *
406 * Because the sub-sequence must lie completely within the range @p
407 * [__first1,__last1) it must start at a position less than @p
408 * __last1-(__last2-__first2) where @p __last2-__first2 is the
409 * length of the sub-sequence. This means that the returned
410 * iterator @c i will be in the range @p
411 * [__first1,__last1-(__last2-__first2))
412 */
413 template<typename _ForwardIterator1, typename _ForwardIterator2,
414 typename _BinaryPredicate>
415 _GLIBCXX20_CONSTEXPR
416 inline _ForwardIterator1
417 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
418 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
419 _BinaryPredicate __comp)
420 {
421 // concept requirements
422 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
423 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
424 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
425 typename iterator_traits<_ForwardIterator1>::value_type,
426 typename iterator_traits<_ForwardIterator2>::value_type>)
427 __glibcxx_requires_valid_range(__first1, __last1);
428 __glibcxx_requires_valid_range(__first2, __last2);
429
430 return std::__find_end(__first1, __last1, __first2, __last2,
431 std::__iterator_category(__first1),
432 std::__iterator_category(__first2),
433 __gnu_cxx::__ops::__iter_comp_iter(__comp));
434 }
435
436#if __cplusplus >= 201103L
437 /**
438 * @brief Checks that a predicate is true for all the elements
439 * of a sequence.
440 * @ingroup non_mutating_algorithms
441 * @param __first An input iterator.
442 * @param __last An input iterator.
443 * @param __pred A predicate.
444 * @return True if the check is true, false otherwise.
445 *
446 * Returns true if @p __pred is true for each element in the range
447 * @p [__first,__last), and false otherwise.
448 */
449 template<typename _InputIterator, typename _Predicate>
450 _GLIBCXX20_CONSTEXPR
451 inline bool
452 all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
453 { return __last == std::find_if_not(__first, __last, __pred); }
454
455 /**
456 * @brief Checks that a predicate is false for all the elements
457 * of a sequence.
458 * @ingroup non_mutating_algorithms
459 * @param __first An input iterator.
460 * @param __last An input iterator.
461 * @param __pred A predicate.
462 * @return True if the check is true, false otherwise.
463 *
464 * Returns true if @p __pred is false for each element in the range
465 * @p [__first,__last), and false otherwise.
466 */
467 template<typename _InputIterator, typename _Predicate>
468 _GLIBCXX20_CONSTEXPR
469 inline bool
470 none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
471 { return __last == _GLIBCXX_STD_A::find_if(__first, __last, __pred); }
472
473 /**
474 * @brief Checks that a predicate is true for at least one element
475 * of a sequence.
476 * @ingroup non_mutating_algorithms
477 * @param __first An input iterator.
478 * @param __last An input iterator.
479 * @param __pred A predicate.
480 * @return True if the check is true, false otherwise.
481 *
482 * Returns true if an element exists in the range @p
483 * [__first,__last) such that @p __pred is true, and false
484 * otherwise.
485 */
486 template<typename _InputIterator, typename _Predicate>
487 _GLIBCXX20_CONSTEXPR
488 inline bool
489 any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
490 { return !std::none_of(__first, __last, __pred); }
491
492 /**
493 * @brief Find the first element in a sequence for which a
494 * predicate is false.
495 * @ingroup non_mutating_algorithms
496 * @param __first An input iterator.
497 * @param __last An input iterator.
498 * @param __pred A predicate.
499 * @return The first iterator @c i in the range @p [__first,__last)
500 * such that @p __pred(*i) is false, or @p __last if no such iterator exists.
501 */
502 template<typename _InputIterator, typename _Predicate>
503 _GLIBCXX20_CONSTEXPR
504 inline _InputIterator
505 find_if_not(_InputIterator __first, _InputIterator __last,
506 _Predicate __pred)
507 {
508 // concept requirements
509 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
510 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
511 typename iterator_traits<_InputIterator>::value_type>)
512 __glibcxx_requires_valid_range(__first, __last);
513 return std::__find_if_not(__first, __last,
514 __gnu_cxx::__ops::__pred_iter(__pred));
515 }
516
517 /**
518 * @brief Checks whether the sequence is partitioned.
519 * @ingroup mutating_algorithms
520 * @param __first An input iterator.
521 * @param __last An input iterator.
522 * @param __pred A predicate.
523 * @return True if the range @p [__first,__last) is partioned by @p __pred,
524 * i.e. if all elements that satisfy @p __pred appear before those that
525 * do not.
526 */
527 template<typename _InputIterator, typename _Predicate>
528 _GLIBCXX20_CONSTEXPR
529 inline bool
530 is_partitioned(_InputIterator __first, _InputIterator __last,
531 _Predicate __pred)
532 {
533 __first = std::find_if_not(__first, __last, __pred);
534 if (__first == __last)
535 return true;
536 ++__first;
537 return std::none_of(__first, __last, __pred);
538 }
539
540 /**
541 * @brief Find the partition point of a partitioned range.
542 * @ingroup mutating_algorithms
543 * @param __first An iterator.
544 * @param __last Another iterator.
545 * @param __pred A predicate.
546 * @return An iterator @p mid such that @p all_of(__first, mid, __pred)
547 * and @p none_of(mid, __last, __pred) are both true.
548 */
549 template<typename _ForwardIterator, typename _Predicate>
550 _GLIBCXX20_CONSTEXPR
551 _ForwardIterator
552 partition_point(_ForwardIterator __first, _ForwardIterator __last,
553 _Predicate __pred)
554 {
555 // concept requirements
556 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
557 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
558 typename iterator_traits<_ForwardIterator>::value_type>)
559
560 // A specific debug-mode test will be necessary...
561 __glibcxx_requires_valid_range(__first, __last);
562
563 typedef typename iterator_traits<_ForwardIterator>::difference_type
564 _DistanceType;
565
566 _DistanceType __len = std::distance(__first, __last);
567
568 while (__len > 0)
569 {
570 _DistanceType __half = __len >> 1;
571 _ForwardIterator __middle = __first;
572 std::advance(__middle, __half);
573 if (__pred(*__middle))
574 {
575 __first = __middle;
576 ++__first;
577 __len = __len - __half - 1;
578 }
579 else
580 __len = __half;
581 }
582 return __first;
583 }
584#endif
585
586 template<typename _InputIterator, typename _OutputIterator,
587 typename _Predicate>
588 _GLIBCXX20_CONSTEXPR
589 _OutputIterator
590 __remove_copy_if(_InputIterator __first, _InputIterator __last,
591 _OutputIterator __result, _Predicate __pred)
592 {
593 for (; __first != __last; ++__first)
594 if (!__pred(__first))
595 {
596 *__result = *__first;
597 ++__result;
598 }
599 return __result;
600 }
601
602 /**
603 * @brief Copy a sequence, removing elements of a given value.
604 * @ingroup mutating_algorithms
605 * @param __first An input iterator.
606 * @param __last An input iterator.
607 * @param __result An output iterator.
608 * @param __value The value to be removed.
609 * @return An iterator designating the end of the resulting sequence.
610 *
611 * Copies each element in the range @p [__first,__last) not equal
612 * to @p __value to the range beginning at @p __result.
613 * remove_copy() is stable, so the relative order of elements that
614 * are copied is unchanged.
615 */
616 template<typename _InputIterator, typename _OutputIterator, typename _Tp>
617 _GLIBCXX20_CONSTEXPR
618 inline _OutputIterator
619 remove_copy(_InputIterator __first, _InputIterator __last,
620 _OutputIterator __result, const _Tp& __value)
621 {
622 // concept requirements
623 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
624 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
625 typename iterator_traits<_InputIterator>::value_type>)
626 __glibcxx_function_requires(_EqualOpConcept<
627 typename iterator_traits<_InputIterator>::value_type, _Tp>)
628 __glibcxx_requires_valid_range(__first, __last);
629
630 return std::__remove_copy_if(__first, __last, __result,
631 __gnu_cxx::__ops::__iter_equals_val(__value));
632 }
633
634 /**
635 * @brief Copy a sequence, removing elements for which a predicate is true.
636 * @ingroup mutating_algorithms
637 * @param __first An input iterator.
638 * @param __last An input iterator.
639 * @param __result An output iterator.
640 * @param __pred A predicate.
641 * @return An iterator designating the end of the resulting sequence.
642 *
643 * Copies each element in the range @p [__first,__last) for which
644 * @p __pred returns false to the range beginning at @p __result.
645 *
646 * remove_copy_if() is stable, so the relative order of elements that are
647 * copied is unchanged.
648 */
649 template<typename _InputIterator, typename _OutputIterator,
650 typename _Predicate>
651 _GLIBCXX20_CONSTEXPR
652 inline _OutputIterator
653 remove_copy_if(_InputIterator __first, _InputIterator __last,
654 _OutputIterator __result, _Predicate __pred)
655 {
656 // concept requirements
657 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
658 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
659 typename iterator_traits<_InputIterator>::value_type>)
660 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
661 typename iterator_traits<_InputIterator>::value_type>)
662 __glibcxx_requires_valid_range(__first, __last);
663
664 return std::__remove_copy_if(__first, __last, __result,
665 __gnu_cxx::__ops::__pred_iter(__pred));
666 }
667
668#if __cplusplus >= 201103L
669 /**
670 * @brief Copy the elements of a sequence for which a predicate is true.
671 * @ingroup mutating_algorithms
672 * @param __first An input iterator.
673 * @param __last An input iterator.
674 * @param __result An output iterator.
675 * @param __pred A predicate.
676 * @return An iterator designating the end of the resulting sequence.
677 *
678 * Copies each element in the range @p [__first,__last) for which
679 * @p __pred returns true to the range beginning at @p __result.
680 *
681 * copy_if() is stable, so the relative order of elements that are
682 * copied is unchanged.
683 */
684 template<typename _InputIterator, typename _OutputIterator,
685 typename _Predicate>
686 _GLIBCXX20_CONSTEXPR
687 _OutputIterator
688 copy_if(_InputIterator __first, _InputIterator __last,
689 _OutputIterator __result, _Predicate __pred)
690 {
691 // concept requirements
692 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
693 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
694 typename iterator_traits<_InputIterator>::value_type>)
695 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
696 typename iterator_traits<_InputIterator>::value_type>)
697 __glibcxx_requires_valid_range(__first, __last);
698
699 for (; __first != __last; ++__first)
700 if (__pred(*__first))
701 {
702 *__result = *__first;
703 ++__result;
704 }
705 return __result;
706 }
707
708 template<typename _InputIterator, typename _Size, typename _OutputIterator>
709 _GLIBCXX20_CONSTEXPR
710 _OutputIterator
711 __copy_n(_InputIterator __first, _Size __n,
712 _OutputIterator __result, input_iterator_tag)
713 {
714 return std::__niter_wrap(__result,
715 __copy_n_a(__first, __n,
716 std::__niter_base(__result), true));
717 }
718
719 template<typename _RandomAccessIterator, typename _Size,
720 typename _OutputIterator>
721 _GLIBCXX20_CONSTEXPR
722 inline _OutputIterator
723 __copy_n(_RandomAccessIterator __first, _Size __n,
724 _OutputIterator __result, random_access_iterator_tag)
725 { return std::copy(__first, __first + __n, __result); }
726
727 /**
728 * @brief Copies the range [first,first+n) into [result,result+n).
729 * @ingroup mutating_algorithms
730 * @param __first An input iterator.
731 * @param __n The number of elements to copy.
732 * @param __result An output iterator.
733 * @return result+n.
734 *
735 * This inline function will boil down to a call to @c memmove whenever
736 * possible. Failing that, if random access iterators are passed, then the
737 * loop count will be known (and therefore a candidate for compiler
738 * optimizations such as unrolling).
739 */
740 template<typename _InputIterator, typename _Size, typename _OutputIterator>
741 _GLIBCXX20_CONSTEXPR
742 inline _OutputIterator
743 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
744 {
745 // concept requirements
746 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
747 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
748 typename iterator_traits<_InputIterator>::value_type>)
749
750 const auto __n2 = std::__size_to_integer(__n);
751 if (__n2 <= 0)
752 return __result;
753
754 __glibcxx_requires_can_increment(__first, __n2);
755 __glibcxx_requires_can_increment(__result, __n2);
756
757 return std::__copy_n(__first, __n2, __result,
758 std::__iterator_category(__first));
759 }
760
761 /**
762 * @brief Copy the elements of a sequence to separate output sequences
763 * depending on the truth value of a predicate.
764 * @ingroup mutating_algorithms
765 * @param __first An input iterator.
766 * @param __last An input iterator.
767 * @param __out_true An output iterator.
768 * @param __out_false An output iterator.
769 * @param __pred A predicate.
770 * @return A pair designating the ends of the resulting sequences.
771 *
772 * Copies each element in the range @p [__first,__last) for which
773 * @p __pred returns true to the range beginning at @p out_true
774 * and each element for which @p __pred returns false to @p __out_false.
775 */
776 template<typename _InputIterator, typename _OutputIterator1,
777 typename _OutputIterator2, typename _Predicate>
778 _GLIBCXX20_CONSTEXPR
779 pair<_OutputIterator1, _OutputIterator2>
780 partition_copy(_InputIterator __first, _InputIterator __last,
781 _OutputIterator1 __out_true, _OutputIterator2 __out_false,
782 _Predicate __pred)
783 {
784 // concept requirements
785 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
786 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
787 typename iterator_traits<_InputIterator>::value_type>)
788 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
789 typename iterator_traits<_InputIterator>::value_type>)
790 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
791 typename iterator_traits<_InputIterator>::value_type>)
792 __glibcxx_requires_valid_range(__first, __last);
793
794 for (; __first != __last; ++__first)
795 if (__pred(*__first))
796 {
797 *__out_true = *__first;
798 ++__out_true;
799 }
800 else
801 {
802 *__out_false = *__first;
803 ++__out_false;
804 }
805
806 return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
807 }
808#endif // C++11
809
810 template<typename _ForwardIterator, typename _Predicate>
811 _GLIBCXX20_CONSTEXPR
812 _ForwardIterator
813 __remove_if(_ForwardIterator __first, _ForwardIterator __last,
814 _Predicate __pred)
815 {
816 __first = std::__find_if(__first, __last, __pred);
817 if (__first == __last)
818 return __first;
819 _ForwardIterator __result = __first;
820 ++__first;
821 for (; __first != __last; ++__first)
822 if (!__pred(__first))
823 {
824 *__result = _GLIBCXX_MOVE(*__first);
825 ++__result;
826 }
827 return __result;
828 }
829
830 /**
831 * @brief Remove elements from a sequence.
832 * @ingroup mutating_algorithms
833 * @param __first An input iterator.
834 * @param __last An input iterator.
835 * @param __value The value to be removed.
836 * @return An iterator designating the end of the resulting sequence.
837 *
838 * All elements equal to @p __value are removed from the range
839 * @p [__first,__last).
840 *
841 * remove() is stable, so the relative order of elements that are
842 * not removed is unchanged.
843 *
844 * Elements between the end of the resulting sequence and @p __last
845 * are still present, but their value is unspecified.
846 */
847 template<typename _ForwardIterator, typename _Tp>
848 _GLIBCXX20_CONSTEXPR
849 inline _ForwardIterator
850 remove(_ForwardIterator __first, _ForwardIterator __last,
851 const _Tp& __value)
852 {
853 // concept requirements
854 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
855 _ForwardIterator>)
856 __glibcxx_function_requires(_EqualOpConcept<
857 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
858 __glibcxx_requires_valid_range(__first, __last);
859
860 return std::__remove_if(__first, __last,
861 __gnu_cxx::__ops::__iter_equals_val(__value));
862 }
863
864 /**
865 * @brief Remove elements from a sequence using a predicate.
866 * @ingroup mutating_algorithms
867 * @param __first A forward iterator.
868 * @param __last A forward iterator.
869 * @param __pred A predicate.
870 * @return An iterator designating the end of the resulting sequence.
871 *
872 * All elements for which @p __pred returns true are removed from the range
873 * @p [__first,__last).
874 *
875 * remove_if() is stable, so the relative order of elements that are
876 * not removed is unchanged.
877 *
878 * Elements between the end of the resulting sequence and @p __last
879 * are still present, but their value is unspecified.
880 */
881 template<typename _ForwardIterator, typename _Predicate>
882 _GLIBCXX20_CONSTEXPR
883 inline _ForwardIterator
884 remove_if(_ForwardIterator __first, _ForwardIterator __last,
885 _Predicate __pred)
886 {
887 // concept requirements
888 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
889 _ForwardIterator>)
890 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
891 typename iterator_traits<_ForwardIterator>::value_type>)
892 __glibcxx_requires_valid_range(__first, __last);
893
894 return std::__remove_if(__first, __last,
895 __gnu_cxx::__ops::__pred_iter(__pred));
896 }
897
898 template<typename _ForwardIterator, typename _BinaryPredicate>
899 _GLIBCXX20_CONSTEXPR
900 _ForwardIterator
901 __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
902 _BinaryPredicate __binary_pred)
903 {
904 if (__first == __last)
905 return __last;
906 _ForwardIterator __next = __first;
907 while (++__next != __last)
908 {
909 if (__binary_pred(__first, __next))
910 return __first;
911 __first = __next;
912 }
913 return __last;
914 }
915
916 template<typename _ForwardIterator, typename _BinaryPredicate>
917 _GLIBCXX20_CONSTEXPR
918 _ForwardIterator
919 __unique(_ForwardIterator __first, _ForwardIterator __last,
920 _BinaryPredicate __binary_pred)
921 {
922 // Skip the beginning, if already unique.
923 __first = std::__adjacent_find(__first, __last, __binary_pred);
924 if (__first == __last)
925 return __last;
926
927 // Do the real copy work.
928 _ForwardIterator __dest = __first;
929 ++__first;
930 while (++__first != __last)
931 if (!__binary_pred(__dest, __first))
932 *++__dest = _GLIBCXX_MOVE(*__first);
933 return ++__dest;
934 }
935
936 /**
937 * @brief Remove consecutive duplicate values from a sequence.
938 * @ingroup mutating_algorithms
939 * @param __first A forward iterator.
940 * @param __last A forward iterator.
941 * @return An iterator designating the end of the resulting sequence.
942 *
943 * Removes all but the first element from each group of consecutive
944 * values that compare equal.
945 * unique() is stable, so the relative order of elements that are
946 * not removed is unchanged.
947 * Elements between the end of the resulting sequence and @p __last
948 * are still present, but their value is unspecified.
949 */
950 template<typename _ForwardIterator>
951 _GLIBCXX20_CONSTEXPR
952 inline _ForwardIterator
953 unique(_ForwardIterator __first, _ForwardIterator __last)
954 {
955 // concept requirements
956 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
957 _ForwardIterator>)
958 __glibcxx_function_requires(_EqualityComparableConcept<
959 typename iterator_traits<_ForwardIterator>::value_type>)
960 __glibcxx_requires_valid_range(__first, __last);
961
962 return std::__unique(__first, __last,
963 __gnu_cxx::__ops::__iter_equal_to_iter());
964 }
965
966 /**
967 * @brief Remove consecutive values from a sequence using a predicate.
968 * @ingroup mutating_algorithms
969 * @param __first A forward iterator.
970 * @param __last A forward iterator.
971 * @param __binary_pred A binary predicate.
972 * @return An iterator designating the end of the resulting sequence.
973 *
974 * Removes all but the first element from each group of consecutive
975 * values for which @p __binary_pred returns true.
976 * unique() is stable, so the relative order of elements that are
977 * not removed is unchanged.
978 * Elements between the end of the resulting sequence and @p __last
979 * are still present, but their value is unspecified.
980 */
981 template<typename _ForwardIterator, typename _BinaryPredicate>
982 _GLIBCXX20_CONSTEXPR
983 inline _ForwardIterator
984 unique(_ForwardIterator __first, _ForwardIterator __last,
985 _BinaryPredicate __binary_pred)
986 {
987 // concept requirements
988 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
989 _ForwardIterator>)
990 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
991 typename iterator_traits<_ForwardIterator>::value_type,
992 typename iterator_traits<_ForwardIterator>::value_type>)
993 __glibcxx_requires_valid_range(__first, __last);
994
995 return std::__unique(__first, __last,
996 __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
997 }
998
999 /**
1000 * This is an uglified
1001 * unique_copy(_InputIterator, _InputIterator, _OutputIterator,
1002 * _BinaryPredicate)
1003 * overloaded for forward iterators and output iterator as result.
1004 */
1005 template<typename _ForwardIterator, typename _OutputIterator,
1006 typename _BinaryPredicate>
1007 _GLIBCXX20_CONSTEXPR
1008 _OutputIterator
1009 __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
1010 _OutputIterator __result, _BinaryPredicate __binary_pred,
1011 forward_iterator_tag, output_iterator_tag)
1012 {
1013 // concept requirements -- iterators already checked
1014 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
1015 typename iterator_traits<_ForwardIterator>::value_type,
1016 typename iterator_traits<_ForwardIterator>::value_type>)
1017
1018 _ForwardIterator __next = __first;
1019 *__result = *__first;
1020 while (++__next != __last)
1021 if (!__binary_pred(__first, __next))
1022 {
1023 __first = __next;
1024 *++__result = *__first;
1025 }
1026 return ++__result;
1027 }
1028
1029 /**
1030 * This is an uglified
1031 * unique_copy(_InputIterator, _InputIterator, _OutputIterator,
1032 * _BinaryPredicate)
1033 * overloaded for input iterators and output iterator as result.
1034 */
1035 template<typename _InputIterator, typename _OutputIterator,
1036 typename _BinaryPredicate>
1037 _GLIBCXX20_CONSTEXPR
1038 _OutputIterator
1039 __unique_copy(_InputIterator __first, _InputIterator __last,
1040 _OutputIterator __result, _BinaryPredicate __binary_pred,
1041 input_iterator_tag, output_iterator_tag)
1042 {
1043 // concept requirements -- iterators already checked
1044 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
1045 typename iterator_traits<_InputIterator>::value_type,
1046 typename iterator_traits<_InputIterator>::value_type>)
1047
1048 typename iterator_traits<_InputIterator>::value_type __value = *__first;
1049 __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
1050 __rebound_pred
1051 = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
1052 *__result = __value;
1053 while (++__first != __last)
1054 if (!__rebound_pred(__first, __value))
1055 {
1056 __value = *__first;
1057 *++__result = __value;
1058 }
1059 return ++__result;
1060 }
1061
1062 /**
1063 * This is an uglified
1064 * unique_copy(_InputIterator, _InputIterator, _OutputIterator,
1065 * _BinaryPredicate)
1066 * overloaded for input iterators and forward iterator as result.
1067 */
1068 template<typename _InputIterator, typename _ForwardIterator,
1069 typename _BinaryPredicate>
1070 _GLIBCXX20_CONSTEXPR
1071 _ForwardIterator
1072 __unique_copy(_InputIterator __first, _InputIterator __last,
1073 _ForwardIterator __result, _BinaryPredicate __binary_pred,
1074 input_iterator_tag, forward_iterator_tag)
1075 {
1076 // concept requirements -- iterators already checked
1077 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
1078 typename iterator_traits<_ForwardIterator>::value_type,
1079 typename iterator_traits<_InputIterator>::value_type>)
1080 *__result = *__first;
1081 while (++__first != __last)
1082 if (!__binary_pred(__result, __first))
1083 *++__result = *__first;
1084 return ++__result;
1085 }
1086
1087 /**
1088 * This is an uglified reverse(_BidirectionalIterator,
1089 * _BidirectionalIterator)
1090 * overloaded for bidirectional iterators.
1091 */
1092 template<typename _BidirectionalIterator>
1093 _GLIBCXX20_CONSTEXPR
1094 void
1095 __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
1096 bidirectional_iterator_tag)
1097 {
1098 while (true)
1099 if (__first == __last || __first == --__last)
1100 return;
1101 else
1102 {
1103 std::iter_swap(__first, __last);
1104 ++__first;
1105 }
1106 }
1107
1108 /**
1109 * This is an uglified reverse(_BidirectionalIterator,
1110 * _BidirectionalIterator)
1111 * overloaded for random access iterators.
1112 */
1113 template<typename _RandomAccessIterator>
1114 _GLIBCXX20_CONSTEXPR
1115 void
1116 __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
1117 random_access_iterator_tag)
1118 {
1119 if (__first == __last)
1120 return;
1121 --__last;
1122 while (__first < __last)
1123 {
1124 std::iter_swap(__first, __last);
1125 ++__first;
1126 --__last;
1127 }
1128 }
1129
1130 /**
1131 * @brief Reverse a sequence.
1132 * @ingroup mutating_algorithms
1133 * @param __first A bidirectional iterator.
1134 * @param __last A bidirectional iterator.
1135 * @return reverse() returns no value.
1136 *
1137 * Reverses the order of the elements in the range @p [__first,__last),
1138 * so that the first element becomes the last etc.
1139 * For every @c i such that @p 0<=i<=(__last-__first)/2), @p reverse()
1140 * swaps @p *(__first+i) and @p *(__last-(i+1))
1141 */
1142 template<typename _BidirectionalIterator>
1143 _GLIBCXX20_CONSTEXPR
1144 inline void
1145 reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
1146 {
1147 // concept requirements
1148 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
1149 _BidirectionalIterator>)
1150 __glibcxx_requires_valid_range(__first, __last);
1151 std::__reverse(__first, __last, std::__iterator_category(__first));
1152 }
1153
1154 /**
1155 * @brief Copy a sequence, reversing its elements.
1156 * @ingroup mutating_algorithms
1157 * @param __first A bidirectional iterator.
1158 * @param __last A bidirectional iterator.
1159 * @param __result An output iterator.
1160 * @return An iterator designating the end of the resulting sequence.
1161 *
1162 * Copies the elements in the range @p [__first,__last) to the
1163 * range @p [__result,__result+(__last-__first)) such that the
1164 * order of the elements is reversed. For every @c i such that @p
1165 * 0<=i<=(__last-__first), @p reverse_copy() performs the
1166 * assignment @p *(__result+(__last-__first)-1-i) = *(__first+i).
1167 * The ranges @p [__first,__last) and @p
1168 * [__result,__result+(__last-__first)) must not overlap.
1169 */
1170 template<typename _BidirectionalIterator, typename _OutputIterator>
1171 _GLIBCXX20_CONSTEXPR
1172 _OutputIterator
1173 reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
1174 _OutputIterator __result)
1175 {
1176 // concept requirements
1177 __glibcxx_function_requires(_BidirectionalIteratorConcept<
1178 _BidirectionalIterator>)
1179 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1180 typename iterator_traits<_BidirectionalIterator>::value_type>)
1181 __glibcxx_requires_valid_range(__first, __last);
1182
1183 while (__first != __last)
1184 {
1185 --__last;
1186 *__result = *__last;
1187 ++__result;
1188 }
1189 return __result;
1190 }
1191
1192 /**
1193 * This is a helper function for the rotate algorithm specialized on RAIs.
1194 * It returns the greatest common divisor of two integer values.
1195 */
1196 template<typename _EuclideanRingElement>
1197 _GLIBCXX20_CONSTEXPR
1198 _EuclideanRingElement
1199 __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
1200 {
1201 while (__n != 0)
1202 {
1203 _EuclideanRingElement __t = __m % __n;
1204 __m = __n;
1205 __n = __t;
1206 }
1207 return __m;
1208 }
1209
1210 inline namespace _V2
1211 {
1212
1213 /// This is a helper function for the rotate algorithm.
1214 template<typename _ForwardIterator>
1215 _GLIBCXX20_CONSTEXPR
1216 _ForwardIterator
1217 __rotate(_ForwardIterator __first,
1218 _ForwardIterator __middle,
1219 _ForwardIterator __last,
1220 forward_iterator_tag)
1221 {
1222 if (__first == __middle)
1223 return __last;
1224 else if (__last == __middle)
1225 return __first;
1226
1227 _ForwardIterator __first2 = __middle;
1228 do
1229 {
1230 std::iter_swap(__first, __first2);
1231 ++__first;
1232 ++__first2;
1233 if (__first == __middle)
1234 __middle = __first2;
1235 }
1236 while (__first2 != __last);
1237
1238 _ForwardIterator __ret = __first;
1239
1240 __first2 = __middle;
1241
1242 while (__first2 != __last)
1243 {
1244 std::iter_swap(__first, __first2);
1245 ++__first;
1246 ++__first2;
1247 if (__first == __middle)
1248 __middle = __first2;
1249 else if (__first2 == __last)
1250 __first2 = __middle;
1251 }
1252 return __ret;
1253 }
1254
1255 /// This is a helper function for the rotate algorithm.
1256 template<typename _BidirectionalIterator>
1257 _GLIBCXX20_CONSTEXPR
1258 _BidirectionalIterator
1259 __rotate(_BidirectionalIterator __first,
1260 _BidirectionalIterator __middle,
1261 _BidirectionalIterator __last,
1262 bidirectional_iterator_tag)
1263 {
1264 // concept requirements
1265 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
1266 _BidirectionalIterator>)
1267
1268 if (__first == __middle)
1269 return __last;
1270 else if (__last == __middle)
1271 return __first;
1272
1273 std::__reverse(__first, __middle, bidirectional_iterator_tag());
1274 std::__reverse(__middle, __last, bidirectional_iterator_tag());
1275
1276 while (__first != __middle && __middle != __last)
1277 {
1278 std::iter_swap(__first, --__last);
1279 ++__first;
1280 }
1281
1282 if (__first == __middle)
1283 {
1284 std::__reverse(__middle, __last, bidirectional_iterator_tag());
1285 return __last;
1286 }
1287 else
1288 {
1289 std::__reverse(__first, __middle, bidirectional_iterator_tag());
1290 return __first;
1291 }
1292 }
1293
1294 /// This is a helper function for the rotate algorithm.
1295 template<typename _RandomAccessIterator>
1296 _GLIBCXX20_CONSTEXPR
1297 _RandomAccessIterator
1298 __rotate(_RandomAccessIterator __first,
1299 _RandomAccessIterator __middle,
1300 _RandomAccessIterator __last,
1301 random_access_iterator_tag)
1302 {
1303 // concept requirements
1304 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
1305 _RandomAccessIterator>)
1306
1307 if (__first == __middle)
1308 return __last;
1309 else if (__last == __middle)
1310 return __first;
1311
1312 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
1313 _Distance;
1314 typedef typename iterator_traits<_RandomAccessIterator>::value_type
1315 _ValueType;
1316
1317 _Distance __n = __last - __first;
1318 _Distance __k = __middle - __first;
1319
1320 if (__k == __n - __k)
1321 {
1322 std::swap_ranges(__first, __middle, __middle);
1323 return __middle;
1324 }
1325
1326 _RandomAccessIterator __p = __first;
1327 _RandomAccessIterator __ret = __first + (__last - __middle);
1328
1329 for (;;)
1330 {
1331 if (__k < __n - __k)
1332 {
1333 if (__is_pod(_ValueType) && __k == 1)
1334 {
1335 _ValueType __t = _GLIBCXX_MOVE(*__p);
1336 _GLIBCXX_MOVE3(__p + 1, __p + __n, __p);
1337 *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
1338 return __ret;
1339 }
1340 _RandomAccessIterator __q = __p + __k;
1341 for (_Distance __i = 0; __i < __n - __k; ++ __i)
1342 {
1343 std::iter_swap(__p, __q);
1344 ++__p;
1345 ++__q;
1346 }
1347 __n %= __k;
1348 if (__n == 0)
1349 return __ret;
1350 std::swap(__n, __k);
1351 __k = __n - __k;
1352 }
1353 else
1354 {
1355 __k = __n - __k;
1356 if (__is_pod(_ValueType) && __k == 1)
1357 {
1358 _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1));
1359 _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n);
1360 *__p = _GLIBCXX_MOVE(__t);
1361 return __ret;
1362 }
1363 _RandomAccessIterator __q = __p + __n;
1364 __p = __q - __k;
1365 for (_Distance __i = 0; __i < __n - __k; ++ __i)
1366 {
1367 --__p;
1368 --__q;
1369 std::iter_swap(__p, __q);
1370 }
1371 __n %= __k;
1372 if (__n == 0)
1373 return __ret;
1374 std::swap(__n, __k);
1375 }
1376 }
1377 }
1378
1379 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1380 // DR 488. rotate throws away useful information
1381 /**
1382 * @brief Rotate the elements of a sequence.
1383 * @ingroup mutating_algorithms
1384 * @param __first A forward iterator.
1385 * @param __middle A forward iterator.
1386 * @param __last A forward iterator.
1387 * @return first + (last - middle).
1388 *
1389 * Rotates the elements of the range @p [__first,__last) by
1390 * @p (__middle - __first) positions so that the element at @p __middle
1391 * is moved to @p __first, the element at @p __middle+1 is moved to
1392 * @p __first+1 and so on for each element in the range
1393 * @p [__first,__last).
1394 *
1395 * This effectively swaps the ranges @p [__first,__middle) and
1396 * @p [__middle,__last).
1397 *
1398 * Performs
1399 * @p *(__first+(n+(__last-__middle))%(__last-__first))=*(__first+n)
1400 * for each @p n in the range @p [0,__last-__first).
1401 */
1402 template<typename _ForwardIterator>
1403 _GLIBCXX20_CONSTEXPR
1404 inline _ForwardIterator
1405 rotate(_ForwardIterator __first, _ForwardIterator __middle,
1406 _ForwardIterator __last)
1407 {
1408 // concept requirements
1409 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
1410 _ForwardIterator>)
1411 __glibcxx_requires_valid_range(__first, __middle);
1412 __glibcxx_requires_valid_range(__middle, __last);
1413
1414 return std::__rotate(__first, __middle, __last,
1415 std::__iterator_category(__first));
1416 }
1417
1418 } // namespace _V2
1419
1420 /**
1421 * @brief Copy a sequence, rotating its elements.
1422 * @ingroup mutating_algorithms
1423 * @param __first A forward iterator.
1424 * @param __middle A forward iterator.
1425 * @param __last A forward iterator.
1426 * @param __result An output iterator.
1427 * @return An iterator designating the end of the resulting sequence.
1428 *
1429 * Copies the elements of the range @p [__first,__last) to the
1430 * range beginning at @result, rotating the copied elements by
1431 * @p (__middle-__first) positions so that the element at @p __middle
1432 * is moved to @p __result, the element at @p __middle+1 is moved
1433 * to @p __result+1 and so on for each element in the range @p
1434 * [__first,__last).
1435 *
1436 * Performs
1437 * @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n)
1438 * for each @p n in the range @p [0,__last-__first).
1439 */
1440 template<typename _ForwardIterator, typename _OutputIterator>
1441 _GLIBCXX20_CONSTEXPR
1442 inline _OutputIterator
1443 rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
1444 _ForwardIterator __last, _OutputIterator __result)
1445 {
1446 // concept requirements
1447 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1448 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1449 typename iterator_traits<_ForwardIterator>::value_type>)
1450 __glibcxx_requires_valid_range(__first, __middle);
1451 __glibcxx_requires_valid_range(__middle, __last);
1452
1453 return std::copy(__first, __middle,
1454 std::copy(__middle, __last, __result));
1455 }
1456
1457 /// This is a helper function...
1458 template<typename _ForwardIterator, typename _Predicate>
1459 _GLIBCXX20_CONSTEXPR
1460 _ForwardIterator
1461 __partition(_ForwardIterator __first, _ForwardIterator __last,
1462 _Predicate __pred, forward_iterator_tag)
1463 {
1464 if (__first == __last)
1465 return __first;
1466
1467 while (__pred(*__first))
1468 if (++__first == __last)
1469 return __first;
1470
1471 _ForwardIterator __next = __first;
1472
1473 while (++__next != __last)
1474 if (__pred(*__next))
1475 {
1476 std::iter_swap(__first, __next);
1477 ++__first;
1478 }
1479
1480 return __first;
1481 }
1482
1483 /// This is a helper function...
1484 template<typename _BidirectionalIterator, typename _Predicate>
1485 _GLIBCXX20_CONSTEXPR
1486 _BidirectionalIterator
1487 __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
1488 _Predicate __pred, bidirectional_iterator_tag)
1489 {
1490 while (true)
1491 {
1492 while (true)
1493 if (__first == __last)
1494 return __first;
1495 else if (__pred(*__first))
1496 ++__first;
1497 else
1498 break;
1499 --__last;
1500 while (true)
1501 if (__first == __last)
1502 return __first;
1503 else if (!bool(__pred(*__last)))
1504 --__last;
1505 else
1506 break;
1507 std::iter_swap(__first, __last);
1508 ++__first;
1509 }
1510 }
1511
1512 // partition
1513
1514 /// This is a helper function...
1515 /// Requires __first != __last and !__pred(__first)
1516 /// and __len == distance(__first, __last).
1517 ///
1518 /// !__pred(__first) allows us to guarantee that we don't
1519 /// move-assign an element onto itself.
1520 template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
1521 typename _Distance>
1522 _ForwardIterator
1523 __stable_partition_adaptive(_ForwardIterator __first,
1524 _ForwardIterator __last,
1525 _Predicate __pred, _Distance __len,
1526 _Pointer __buffer,
1527 _Distance __buffer_size)
1528 {
1529 if (__len == 1)
1530 return __first;
1531
1532 if (__len <= __buffer_size)
1533 {
1534 _ForwardIterator __result1 = __first;
1535 _Pointer __result2 = __buffer;
1536
1537 // The precondition guarantees that !__pred(__first), so
1538 // move that element to the buffer before starting the loop.
1539 // This ensures that we only call __pred once per element.
1540 *__result2 = _GLIBCXX_MOVE(*__first);
1541 ++__result2;
1542 ++__first;
1543 for (; __first != __last; ++__first)
1544 if (__pred(__first))
1545 {
1546 *__result1 = _GLIBCXX_MOVE(*__first);
1547 ++__result1;
1548 }
1549 else
1550 {
1551 *__result2 = _GLIBCXX_MOVE(*__first);
1552 ++__result2;
1553 }
1554
1555 _GLIBCXX_MOVE3(__buffer, __result2, __result1);
1556 return __result1;
1557 }
1558
1559 _ForwardIterator __middle = __first;
1560 std::advance(__middle, __len / 2);
1561 _ForwardIterator __left_split =
1562 std::__stable_partition_adaptive(__first, __middle, __pred,
1563 __len / 2, __buffer,
1564 __buffer_size);
1565
1566 // Advance past true-predicate values to satisfy this
1567 // function's preconditions.
1568 _Distance __right_len = __len - __len / 2;
1569 _ForwardIterator __right_split =
1570 std::__find_if_not_n(__middle, __right_len, __pred);
1571
1572 if (__right_len)
1573 __right_split =
1574 std::__stable_partition_adaptive(__right_split, __last, __pred,
1575 __right_len,
1576 __buffer, __buffer_size);
1577
1578 return std::rotate(__left_split, __middle, __right_split);
1579 }
1580
1581 template<typename _ForwardIterator, typename _Predicate>
1582 _ForwardIterator
1583 __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
1584 _Predicate __pred)
1585 {
1586 __first = std::__find_if_not(__first, __last, __pred);
1587
1588 if (__first == __last)
1589 return __first;
1590
1591 typedef typename iterator_traits<_ForwardIterator>::value_type
1592 _ValueType;
1593 typedef typename iterator_traits<_ForwardIterator>::difference_type
1594 _DistanceType;
1595
1596 _Temporary_buffer<_ForwardIterator, _ValueType>
1597 __buf(__first, std::distance(__first, __last));
1598 return
1599 std::__stable_partition_adaptive(__first, __last, __pred,
1600 _DistanceType(__buf.requested_size()),
1601 __buf.begin(),
1602 _DistanceType(__buf.size()));
1603 }
1604
1605 /**
1606 * @brief Move elements for which a predicate is true to the beginning
1607 * of a sequence, preserving relative ordering.
1608 * @ingroup mutating_algorithms
1609 * @param __first A forward iterator.
1610 * @param __last A forward iterator.
1611 * @param __pred A predicate functor.
1612 * @return An iterator @p middle such that @p __pred(i) is true for each
1613 * iterator @p i in the range @p [first,middle) and false for each @p i
1614 * in the range @p [middle,last).
1615 *
1616 * Performs the same function as @p partition() with the additional
1617 * guarantee that the relative ordering of elements in each group is
1618 * preserved, so any two elements @p x and @p y in the range
1619 * @p [__first,__last) such that @p __pred(x)==__pred(y) will have the same
1620 * relative ordering after calling @p stable_partition().
1621 */
1622 template<typename _ForwardIterator, typename _Predicate>
1623 inline _ForwardIterator
1624 stable_partition(_ForwardIterator __first, _ForwardIterator __last,
1625 _Predicate __pred)
1626 {
1627 // concept requirements
1628 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
1629 _ForwardIterator>)
1630 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
1631 typename iterator_traits<_ForwardIterator>::value_type>)
1632 __glibcxx_requires_valid_range(__first, __last);
1633
1634 return std::__stable_partition(__first, __last,
1635 __gnu_cxx::__ops::__pred_iter(__pred));
1636 }
1637
1638 /// This is a helper function for the sort routines.
1639 template<typename _RandomAccessIterator, typename _Compare>
1640 _GLIBCXX20_CONSTEXPR
1641 void
1642 __heap_select(_RandomAccessIterator __first,
1643 _RandomAccessIterator __middle,
1644 _RandomAccessIterator __last, _Compare __comp)
1645 {
1646 std::__make_heap(__first, __middle, __comp);
1647 for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
1648 if (__comp(__i, __first))
1649 std::__pop_heap(__first, __middle, __i, __comp);
1650 }
1651
1652 // partial_sort
1653
1654 template<typename _InputIterator, typename _RandomAccessIterator,
1655 typename _Compare>
1656 _GLIBCXX20_CONSTEXPR
1657 _RandomAccessIterator
1658 __partial_sort_copy(_InputIterator __first, _InputIterator __last,
1659 _RandomAccessIterator __result_first,
1660 _RandomAccessIterator __result_last,
1661 _Compare __comp)
1662 {
1663 typedef typename iterator_traits<_InputIterator>::value_type
1664 _InputValueType;
1665 typedef iterator_traits<_RandomAccessIterator> _RItTraits;
1666 typedef typename _RItTraits::difference_type _DistanceType;
1667
1668 if (__result_first == __result_last)
1669 return __result_last;
1670 _RandomAccessIterator __result_real_last = __result_first;
1671 while (__first != __last && __result_real_last != __result_last)
1672 {
1673 *__result_real_last = *__first;
1674 ++__result_real_last;
1675 ++__first;
1676 }
1677
1678 std::__make_heap(__result_first, __result_real_last, __comp);
1679 while (__first != __last)
1680 {
1681 if (__comp(__first, __result_first))
1682 std::__adjust_heap(__result_first, _DistanceType(0),
1683 _DistanceType(__result_real_last
1684 - __result_first),
1685 _InputValueType(*__first), __comp);
1686 ++__first;
1687 }
1688 std::__sort_heap(__result_first, __result_real_last, __comp);
1689 return __result_real_last;
1690 }
1691
1692 /**
1693 * @brief Copy the smallest elements of a sequence.
1694 * @ingroup sorting_algorithms
1695 * @param __first An iterator.
1696 * @param __last Another iterator.
1697 * @param __result_first A random-access iterator.
1698 * @param __result_last Another random-access iterator.
1699 * @return An iterator indicating the end of the resulting sequence.
1700 *
1701 * Copies and sorts the smallest N values from the range @p [__first,__last)
1702 * to the range beginning at @p __result_first, where the number of
1703 * elements to be copied, @p N, is the smaller of @p (__last-__first) and
1704 * @p (__result_last-__result_first).
1705 * After the sort if @e i and @e j are iterators in the range
1706 * @p [__result_first,__result_first+N) such that i precedes j then
1707 * *j<*i is false.
1708 * The value returned is @p __result_first+N.
1709 */
1710 template<typename _InputIterator, typename _RandomAccessIterator>
1711 _GLIBCXX20_CONSTEXPR
1712 inline _RandomAccessIterator
1713 partial_sort_copy(_InputIterator __first, _InputIterator __last,
1714 _RandomAccessIterator __result_first,
1715 _RandomAccessIterator __result_last)
1716 {
1717#ifdef _GLIBCXX_CONCEPT_CHECKS
1718 typedef typename iterator_traits<_InputIterator>::value_type
1719 _InputValueType;
1720 typedef typename iterator_traits<_RandomAccessIterator>::value_type
1721 _OutputValueType;
1722#endif
1723
1724 // concept requirements
1725 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
1726 __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
1727 _OutputValueType>)
1728 __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
1729 _OutputValueType>)
1730 __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
1731 __glibcxx_requires_valid_range(__first, __last);
1732 __glibcxx_requires_irreflexive(__first, __last);
1733 __glibcxx_requires_valid_range(__result_first, __result_last);
1734
1735 return std::__partial_sort_copy(__first, __last,
1736 __result_first, __result_last,
1737 __gnu_cxx::__ops::__iter_less_iter());
1738 }
1739
1740 /**
1741 * @brief Copy the smallest elements of a sequence using a predicate for
1742 * comparison.
1743 * @ingroup sorting_algorithms
1744 * @param __first An input iterator.
1745 * @param __last Another input iterator.
1746 * @param __result_first A random-access iterator.
1747 * @param __result_last Another random-access iterator.
1748 * @param __comp A comparison functor.
1749 * @return An iterator indicating the end of the resulting sequence.
1750 *
1751 * Copies and sorts the smallest N values from the range @p [__first,__last)
1752 * to the range beginning at @p result_first, where the number of
1753 * elements to be copied, @p N, is the smaller of @p (__last-__first) and
1754 * @p (__result_last-__result_first).
1755 * After the sort if @e i and @e j are iterators in the range
1756 * @p [__result_first,__result_first+N) such that i precedes j then
1757 * @p __comp(*j,*i) is false.
1758 * The value returned is @p __result_first+N.
1759 */
1760 template<typename _InputIterator, typename _RandomAccessIterator,
1761 typename _Compare>
1762 _GLIBCXX20_CONSTEXPR
1763 inline _RandomAccessIterator
1764 partial_sort_copy(_InputIterator __first, _InputIterator __last,
1765 _RandomAccessIterator __result_first,
1766 _RandomAccessIterator __result_last,
1767 _Compare __comp)
1768 {
1769#ifdef _GLIBCXX_CONCEPT_CHECKS
1770 typedef typename iterator_traits<_InputIterator>::value_type
1771 _InputValueType;
1772 typedef typename iterator_traits<_RandomAccessIterator>::value_type
1773 _OutputValueType;
1774#endif
1775
1776 // concept requirements
1777 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
1778 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
1779 _RandomAccessIterator>)
1780 __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
1781 _OutputValueType>)
1782 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
1783 _InputValueType, _OutputValueType>)
1784 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
1785 _OutputValueType, _OutputValueType>)
1786 __glibcxx_requires_valid_range(__first, __last);
1787 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
1788 __glibcxx_requires_valid_range(__result_first, __result_last);
1789
1790 return std::__partial_sort_copy(__first, __last,
1791 __result_first, __result_last,
1792 __gnu_cxx::__ops::__iter_comp_iter(__comp));
1793 }
1794
1795 /// This is a helper function for the sort routine.
1796 template<typename _RandomAccessIterator, typename _Compare>
1797 _GLIBCXX20_CONSTEXPR
1798 void
1799 __unguarded_linear_insert(_RandomAccessIterator __last,
1800 _Compare __comp)
1801 {
1802 typename iterator_traits<_RandomAccessIterator>::value_type
1803 __val = _GLIBCXX_MOVE(*__last);
1804 _RandomAccessIterator __next = __last;
1805 --__next;
1806 while (__comp(__val, __next))
1807 {
1808 *__last = _GLIBCXX_MOVE(*__next);
1809 __last = __next;
1810 --__next;
1811 }
1812 *__last = _GLIBCXX_MOVE(__val);
1813 }
1814
1815 /// This is a helper function for the sort routine.
1816 template<typename _RandomAccessIterator, typename _Compare>
1817 _GLIBCXX20_CONSTEXPR
1818 void
1819 __insertion_sort(_RandomAccessIterator __first,
1820 _RandomAccessIterator __last, _Compare __comp)
1821 {
1822 if (__first == __last) return;
1823
1824 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
1825 {
1826 if (__comp(__i, __first))
1827 {
1828 typename iterator_traits<_RandomAccessIterator>::value_type
1829 __val = _GLIBCXX_MOVE(*__i);
1830 _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
1831 *__first = _GLIBCXX_MOVE(__val);
1832 }
1833 else
1834 std::__unguarded_linear_insert(__i,
1835 __gnu_cxx::__ops::__val_comp_iter(__comp));
1836 }
1837 }
1838
1839 /// This is a helper function for the sort routine.
1840 template<typename _RandomAccessIterator, typename _Compare>
1841 _GLIBCXX20_CONSTEXPR
1842 inline void
1843 __unguarded_insertion_sort(_RandomAccessIterator __first,
1844 _RandomAccessIterator __last, _Compare __comp)
1845 {
1846 for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
1847 std::__unguarded_linear_insert(__i,
1848 __gnu_cxx::__ops::__val_comp_iter(__comp));
1849 }
1850
1851 /**
1852 * @doctodo
1853 * This controls some aspect of the sort routines.
1854 */
1855 enum { _S_threshold = 16 };
1856
1857 /// This is a helper function for the sort routine.
1858 template<typename _RandomAccessIterator, typename _Compare>
1859 _GLIBCXX20_CONSTEXPR
1860 void
1861 __final_insertion_sort(_RandomAccessIterator __first,
1862 _RandomAccessIterator __last, _Compare __comp)
1863 {
1864 if (__last - __first > int(_S_threshold))
1865 {
1866 std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
1867 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
1868 __comp);
1869 }
1870 else
1871 std::__insertion_sort(__first, __last, __comp);
1872 }
1873
1874 /// This is a helper function...
1875 template<typename _RandomAccessIterator, typename _Compare>
1876 _GLIBCXX20_CONSTEXPR
1877 _RandomAccessIterator
1878 __unguarded_partition(_RandomAccessIterator __first,
1879 _RandomAccessIterator __last,
1880 _RandomAccessIterator __pivot, _Compare __comp)
1881 {
1882 while (true)
1883 {
1884 while (__comp(__first, __pivot))
1885 ++__first;
1886 --__last;
1887 while (__comp(__pivot, __last))
1888 --__last;
1889 if (!(__first < __last))
1890 return __first;
1891 std::iter_swap(__first, __last);
1892 ++__first;
1893 }
1894 }
1895
1896 /// This is a helper function...
1897 template<typename _RandomAccessIterator, typename _Compare>
1898 _GLIBCXX20_CONSTEXPR
1899 inline _RandomAccessIterator
1900 __unguarded_partition_pivot(_RandomAccessIterator __first,
1901 _RandomAccessIterator __last, _Compare __comp)
1902 {
1903 _RandomAccessIterator __mid = __first + (__last - __first) / 2;
1904 std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
1905 __comp);
1906 return std::__unguarded_partition(__first + 1, __last, __first, __comp);
1907 }
1908
1909 template<typename _RandomAccessIterator, typename _Compare>
1910 _GLIBCXX20_CONSTEXPR
1911 inline void
1912 __partial_sort(_RandomAccessIterator __first,
1913 _RandomAccessIterator __middle,
1914 _RandomAccessIterator __last,
1915 _Compare __comp)
1916 {
1917 std::__heap_select(__first, __middle, __last, __comp);
1918 std::__sort_heap(__first, __middle, __comp);
1919 }
1920
1921 /// This is a helper function for the sort routine.
1922 template<typename _RandomAccessIterator, typename _Size, typename _Compare>
1923 _GLIBCXX20_CONSTEXPR
1924 void
1925 __introsort_loop(_RandomAccessIterator __first,
1926 _RandomAccessIterator __last,
1927 _Size __depth_limit, _Compare __comp)
1928 {
1929 while (__last - __first > int(_S_threshold))
1930 {
1931 if (__depth_limit == 0)
1932 {
1933 std::__partial_sort(__first, __last, __last, __comp);
1934 return;
1935 }
1936 --__depth_limit;
1937 _RandomAccessIterator __cut =
1938 std::__unguarded_partition_pivot(__first, __last, __comp);
1939 std::__introsort_loop(__cut, __last, __depth_limit, __comp);
1940 __last = __cut;
1941 }
1942 }
1943
1944 // sort
1945
1946 template<typename _RandomAccessIterator, typename _Compare>
1947 _GLIBCXX20_CONSTEXPR
1948 inline void
1949 __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
1950 _Compare __comp)
1951 {
1952 if (__first != __last)
1953 {
1954 std::__introsort_loop(__first, __last,
1955 std::__lg(__last - __first) * 2,
1956 __comp);
1957 std::__final_insertion_sort(__first, __last, __comp);
1958 }
1959 }
1960
1961 template<typename _RandomAccessIterator, typename _Size, typename _Compare>
1962 _GLIBCXX20_CONSTEXPR
1963 void
1964 __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
1965 _RandomAccessIterator __last, _Size __depth_limit,
1966 _Compare __comp)
1967 {
1968 while (__last - __first > 3)
1969 {
1970 if (__depth_limit == 0)
1971 {
1972 std::__heap_select(__first, __nth + 1, __last, __comp);
1973 // Place the nth largest element in its final position.
1974 std::iter_swap(__first, __nth);
1975 return;
1976 }
1977 --__depth_limit;
1978 _RandomAccessIterator __cut =
1979 std::__unguarded_partition_pivot(__first, __last, __comp);
1980 if (__cut <= __nth)
1981 __first = __cut;
1982 else
1983 __last = __cut;
1984 }
1985 std::__insertion_sort(__first, __last, __comp);
1986 }
1987
1988 // nth_element
1989
1990 // lower_bound moved to stl_algobase.h
1991
1992 /**
1993 * @brief Finds the first position in which @p __val could be inserted
1994 * without changing the ordering.
1995 * @ingroup binary_search_algorithms
1996 * @param __first An iterator.
1997 * @param __last Another iterator.
1998 * @param __val The search term.
1999 * @param __comp A functor to use for comparisons.
2000 * @return An iterator pointing to the first element <em>not less
2001 * than</em> @p __val, or end() if every element is less
2002 * than @p __val.
2003 * @ingroup binary_search_algorithms
2004 *
2005 * The comparison function should have the same effects on ordering as
2006 * the function used for the initial sort.
2007 */
2008 template<typename _ForwardIterator, typename _Tp, typename _Compare>
2009 _GLIBCXX20_CONSTEXPR
2010 inline _ForwardIterator
2011 lower_bound(_ForwardIterator __first, _ForwardIterator __last,
2012 const _Tp& __val, _Compare __comp)
2013 {
2014 // concept requirements
2015 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2016 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2017 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
2018 __glibcxx_requires_partitioned_lower_pred(__first, __last,
2019 __val, __comp);
2020
2021 return std::__lower_bound(__first, __last, __val,
2022 __gnu_cxx::__ops::__iter_comp_val(__comp));
2023 }
2024
2025 template<typename _ForwardIterator, typename _Tp, typename _Compare>
2026 _GLIBCXX20_CONSTEXPR
2027 _ForwardIterator
2028 __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
2029 const _Tp& __val, _Compare __comp)
2030 {
2031 typedef typename iterator_traits<_ForwardIterator>::difference_type
2032 _DistanceType;
2033
2034 _DistanceType __len = std::distance(__first, __last);
2035
2036 while (__len > 0)
2037 {
2038 _DistanceType __half = __len >> 1;
2039 _ForwardIterator __middle = __first;
2040 std::advance(__middle, __half);
2041 if (__comp(__val, __middle))
2042 __len = __half;
2043 else
2044 {
2045 __first = __middle;
2046 ++__first;
2047 __len = __len - __half - 1;
2048 }
2049 }
2050 return __first;
2051 }
2052
2053 /**
2054 * @brief Finds the last position in which @p __val could be inserted
2055 * without changing the ordering.
2056 * @ingroup binary_search_algorithms
2057 * @param __first An iterator.
2058 * @param __last Another iterator.
2059 * @param __val The search term.
2060 * @return An iterator pointing to the first element greater than @p __val,
2061 * or end() if no elements are greater than @p __val.
2062 * @ingroup binary_search_algorithms
2063 */
2064 template<typename _ForwardIterator, typename _Tp>
2065 _GLIBCXX20_CONSTEXPR
2066 inline _ForwardIterator
2067 upper_bound(_ForwardIterator __first, _ForwardIterator __last,
2068 const _Tp& __val)
2069 {
2070 // concept requirements
2071 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2072 __glibcxx_function_requires(_LessThanOpConcept<
2073 _Tp, typename iterator_traits<_ForwardIterator>::value_type>)
2074 __glibcxx_requires_partitioned_upper(__first, __last, __val);
2075
2076 return std::__upper_bound(__first, __last, __val,
2077 __gnu_cxx::__ops::__val_less_iter());
2078 }
2079
2080 /**
2081 * @brief Finds the last position in which @p __val could be inserted
2082 * without changing the ordering.
2083 * @ingroup binary_search_algorithms
2084 * @param __first An iterator.
2085 * @param __last Another iterator.
2086 * @param __val The search term.
2087 * @param __comp A functor to use for comparisons.
2088 * @return An iterator pointing to the first element greater than @p __val,
2089 * or end() if no elements are greater than @p __val.
2090 * @ingroup binary_search_algorithms
2091 *
2092 * The comparison function should have the same effects on ordering as
2093 * the function used for the initial sort.
2094 */
2095 template<typename _ForwardIterator, typename _Tp, typename _Compare>
2096 _GLIBCXX20_CONSTEXPR
2097 inline _ForwardIterator
2098 upper_bound(_ForwardIterator __first, _ForwardIterator __last,
2099 const _Tp& __val, _Compare __comp)
2100 {
2101 // concept requirements
2102 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2103 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2104 _Tp, typename iterator_traits<_ForwardIterator>::value_type>)
2105 __glibcxx_requires_partitioned_upper_pred(__first, __last,
2106 __val, __comp);
2107
2108 return std::__upper_bound(__first, __last, __val,
2109 __gnu_cxx::__ops::__val_comp_iter(__comp));
2110 }
2111
2112 template<typename _ForwardIterator, typename _Tp,
2113 typename _CompareItTp, typename _CompareTpIt>
2114 _GLIBCXX20_CONSTEXPR
2115 pair<_ForwardIterator, _ForwardIterator>
2116 __equal_range(_ForwardIterator __first, _ForwardIterator __last,
2117 const _Tp& __val,
2118 _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
2119 {
2120 typedef typename iterator_traits<_ForwardIterator>::difference_type
2121 _DistanceType;
2122
2123 _DistanceType __len = std::distance(__first, __last);
2124
2125 while (__len > 0)
2126 {
2127 _DistanceType __half = __len >> 1;
2128 _ForwardIterator __middle = __first;
2129 std::advance(__middle, __half);
2130 if (__comp_it_val(__middle, __val))
2131 {
2132 __first = __middle;
2133 ++__first;
2134 __len = __len - __half - 1;
2135 }
2136 else if (__comp_val_it(__val, __middle))
2137 __len = __half;
2138 else
2139 {
2140 _ForwardIterator __left
2141 = std::__lower_bound(__first, __middle, __val, __comp_it_val);
2142 std::advance(__first, __len);
2143 _ForwardIterator __right
2144 = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
2145 return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
2146 }
2147 }
2148 return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
2149 }
2150
2151 /**
2152 * @brief Finds the largest subrange in which @p __val could be inserted
2153 * at any place in it without changing the ordering.
2154 * @ingroup binary_search_algorithms
2155 * @param __first An iterator.
2156 * @param __last Another iterator.
2157 * @param __val The search term.
2158 * @return An pair of iterators defining the subrange.
2159 * @ingroup binary_search_algorithms
2160 *
2161 * This is equivalent to
2162 * @code
2163 * std::make_pair(lower_bound(__first, __last, __val),
2164 * upper_bound(__first, __last, __val))
2165 * @endcode
2166 * but does not actually call those functions.
2167 */
2168 template<typename _ForwardIterator, typename _Tp>
2169 _GLIBCXX20_CONSTEXPR
2170 inline pair<_ForwardIterator, _ForwardIterator>
2171 equal_range(_ForwardIterator __first, _ForwardIterator __last,
2172 const _Tp& __val)
2173 {
2174 // concept requirements
2175 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2176 __glibcxx_function_requires(_LessThanOpConcept<
2177 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
2178 __glibcxx_function_requires(_LessThanOpConcept<
2179 _Tp, typename iterator_traits<_ForwardIterator>::value_type>)
2180 __glibcxx_requires_partitioned_lower(__first, __last, __val);
2181 __glibcxx_requires_partitioned_upper(__first, __last, __val);
2182
2183 return std::__equal_range(__first, __last, __val,
2184 __gnu_cxx::__ops::__iter_less_val(),
2185 __gnu_cxx::__ops::__val_less_iter());
2186 }
2187
2188 /**
2189 * @brief Finds the largest subrange in which @p __val could be inserted
2190 * at any place in it without changing the ordering.
2191 * @param __first An iterator.
2192 * @param __last Another iterator.
2193 * @param __val The search term.
2194 * @param __comp A functor to use for comparisons.
2195 * @return An pair of iterators defining the subrange.
2196 * @ingroup binary_search_algorithms
2197 *
2198 * This is equivalent to
2199 * @code
2200 * std::make_pair(lower_bound(__first, __last, __val, __comp),
2201 * upper_bound(__first, __last, __val, __comp))
2202 * @endcode
2203 * but does not actually call those functions.
2204 */
2205 template<typename _ForwardIterator, typename _Tp, typename _Compare>
2206 _GLIBCXX20_CONSTEXPR
2207 inline pair<_ForwardIterator, _ForwardIterator>
2208 equal_range(_ForwardIterator __first, _ForwardIterator __last,
2209 const _Tp& __val, _Compare __comp)
2210 {
2211 // concept requirements
2212 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2213 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2214 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
2215 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2216 _Tp, typename iterator_traits<_ForwardIterator>::value_type>)
2217 __glibcxx_requires_partitioned_lower_pred(__first, __last,
2218 __val, __comp);
2219 __glibcxx_requires_partitioned_upper_pred(__first, __last,
2220 __val, __comp);
2221
2222 return std::__equal_range(__first, __last, __val,
2223 __gnu_cxx::__ops::__iter_comp_val(__comp),
2224 __gnu_cxx::__ops::__val_comp_iter(__comp));
2225 }
2226
2227 /**
2228 * @brief Determines whether an element exists in a range.
2229 * @ingroup binary_search_algorithms
2230 * @param __first An iterator.
2231 * @param __last Another iterator.
2232 * @param __val The search term.
2233 * @return True if @p __val (or its equivalent) is in [@p
2234 * __first,@p __last ].
2235 *
2236 * Note that this does not actually return an iterator to @p __val. For
2237 * that, use std::find or a container's specialized find member functions.
2238 */
2239 template<typename _ForwardIterator, typename _Tp>
2240 _GLIBCXX20_CONSTEXPR
2241 bool
2242 binary_search(_ForwardIterator __first, _ForwardIterator __last,
2243 const _Tp& __val)
2244 {
2245 // concept requirements
2246 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2247 __glibcxx_function_requires(_LessThanOpConcept<
2248 _Tp, typename iterator_traits<_ForwardIterator>::value_type>)
2249 __glibcxx_requires_partitioned_lower(__first, __last, __val);
2250 __glibcxx_requires_partitioned_upper(__first, __last, __val);
2251
2252 _ForwardIterator __i
2253 = std::__lower_bound(__first, __last, __val,
2254 __gnu_cxx::__ops::__iter_less_val());
2255 return __i != __last && !(__val < *__i);
2256 }
2257
2258 /**
2259 * @brief Determines whether an element exists in a range.
2260 * @ingroup binary_search_algorithms
2261 * @param __first An iterator.
2262 * @param __last Another iterator.
2263 * @param __val The search term.
2264 * @param __comp A functor to use for comparisons.
2265 * @return True if @p __val (or its equivalent) is in @p [__first,__last].
2266 *
2267 * Note that this does not actually return an iterator to @p __val. For
2268 * that, use std::find or a container's specialized find member functions.
2269 *
2270 * The comparison function should have the same effects on ordering as
2271 * the function used for the initial sort.
2272 */
2273 template<typename _ForwardIterator, typename _Tp, typename _Compare>
2274 _GLIBCXX20_CONSTEXPR
2275 bool
2276 binary_search(_ForwardIterator __first, _ForwardIterator __last,
2277 const _Tp& __val, _Compare __comp)
2278 {
2279 // concept requirements
2280 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2281 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2282 _Tp, typename iterator_traits<_ForwardIterator>::value_type>)
2283 __glibcxx_requires_partitioned_lower_pred(__first, __last,
2284 __val, __comp);
2285 __glibcxx_requires_partitioned_upper_pred(__first, __last,
2286 __val, __comp);
2287
2288 _ForwardIterator __i
2289 = std::__lower_bound(__first, __last, __val,
2290 __gnu_cxx::__ops::__iter_comp_val(__comp));
2291 return __i != __last && !bool(__comp(__val, *__i));
2292 }
2293
2294 // merge
2295
2296 /// This is a helper function for the __merge_adaptive routines.
2297 template<typename _InputIterator1, typename _InputIterator2,
2298 typename _OutputIterator, typename _Compare>
2299 void
2300 __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
2301 _InputIterator2 __first2, _InputIterator2 __last2,
2302 _OutputIterator __result, _Compare __comp)
2303 {
2304 while (__first1 != __last1 && __first2 != __last2)
2305 {
2306 if (__comp(__first2, __first1))
2307 {
2308 *__result = _GLIBCXX_MOVE(*__first2);
2309 ++__first2;
2310 }
2311 else
2312 {
2313 *__result = _GLIBCXX_MOVE(*__first1);
2314 ++__first1;
2315 }
2316 ++__result;
2317 }
2318 if (__first1 != __last1)
2319 _GLIBCXX_MOVE3(__first1, __last1, __result);
2320 }
2321
2322 /// This is a helper function for the __merge_adaptive routines.
2323 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
2324 typename _BidirectionalIterator3, typename _Compare>
2325 void
2326 __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
2327 _BidirectionalIterator1 __last1,
2328 _BidirectionalIterator2 __first2,
2329 _BidirectionalIterator2 __last2,
2330 _BidirectionalIterator3 __result,
2331 _Compare __comp)
2332 {
2333 if (__first1 == __last1)
2334 {
2335 _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
2336 return;
2337 }
2338 else if (__first2 == __last2)
2339 return;
2340
2341 --__last1;
2342 --__last2;
2343 while (true)
2344 {
2345 if (__comp(__last2, __last1))
2346 {
2347 *--__result = _GLIBCXX_MOVE(*__last1);
2348 if (__first1 == __last1)
2349 {
2350 _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
2351 return;
2352 }
2353 --__last1;
2354 }
2355 else
2356 {
2357 *--__result = _GLIBCXX_MOVE(*__last2);
2358 if (__first2 == __last2)
2359 return;
2360 --__last2;
2361 }
2362 }
2363 }
2364
2365 /// This is a helper function for the merge routines.
2366 template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
2367 typename _Distance>
2368 _BidirectionalIterator1
2369 __rotate_adaptive(_BidirectionalIterator1 __first,
2370 _BidirectionalIterator1 __middle,
2371 _BidirectionalIterator1 __last,
2372 _Distance __len1, _Distance __len2,
2373 _BidirectionalIterator2 __buffer,
2374 _Distance __buffer_size)
2375 {
2376 _BidirectionalIterator2 __buffer_end;
2377 if (__len1 > __len2 && __len2 <= __buffer_size)
2378 {
2379 if (__len2)
2380 {
2381 __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
2382 _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last);
2383 return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first);
2384 }
2385 else
2386 return __first;
2387 }
2388 else if (__len1 <= __buffer_size)
2389 {
2390 if (__len1)
2391 {
2392 __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
2393 _GLIBCXX_MOVE3(__middle, __last, __first);
2394 return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last);
2395 }
2396 else
2397 return __last;
2398 }
2399 else
2400 return std::rotate(__first, __middle, __last);
2401 }
2402
2403 /// This is a helper function for the merge routines.
2404 template<typename _BidirectionalIterator, typename _Distance,
2405 typename _Pointer, typename _Compare>
2406 void
2407 __merge_adaptive(_BidirectionalIterator __first,
2408 _BidirectionalIterator __middle,
2409 _BidirectionalIterator __last,
2410 _Distance __len1, _Distance __len2,
2411 _Pointer __buffer, _Distance __buffer_size,
2412 _Compare __comp)
2413 {
2414 if (__len1 <= __len2 && __len1 <= __buffer_size)
2415 {
2416 _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
2417 std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
2418 __first, __comp);
2419 }
2420 else if (__len2 <= __buffer_size)
2421 {
2422 _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
2423 std::__move_merge_adaptive_backward(__first, __middle, __buffer,
2424 __buffer_end, __last, __comp);
2425 }
2426 else
2427 {
2428 _BidirectionalIterator __first_cut = __first;
2429 _BidirectionalIterator __second_cut = __middle;
2430 _Distance __len11 = 0;
2431 _Distance __len22 = 0;
2432 if (__len1 > __len2)
2433 {
2434 __len11 = __len1 / 2;
2435 std::advance(__first_cut, __len11);
2436 __second_cut
2437 = std::__lower_bound(__middle, __last, *__first_cut,
2438 __gnu_cxx::__ops::__iter_comp_val(__comp));
2439 __len22 = std::distance(__middle, __second_cut);
2440 }
2441 else
2442 {
2443 __len22 = __len2 / 2;
2444 std::advance(__second_cut, __len22);
2445 __first_cut
2446 = std::__upper_bound(__first, __middle, *__second_cut,
2447 __gnu_cxx::__ops::__val_comp_iter(__comp));
2448 __len11 = std::distance(__first, __first_cut);
2449 }
2450
2451 _BidirectionalIterator __new_middle
2452 = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
2453 __len1 - __len11, __len22, __buffer,
2454 __buffer_size);
2455 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
2456 __len22, __buffer, __buffer_size, __comp);
2457 std::__merge_adaptive(__new_middle, __second_cut, __last,
2458 __len1 - __len11,
2459 __len2 - __len22, __buffer,
2460 __buffer_size, __comp);
2461 }
2462 }
2463
2464 /// This is a helper function for the merge routines.
2465 template<typename _BidirectionalIterator, typename _Distance,
2466 typename _Compare>
2467 void
2468 __merge_without_buffer(_BidirectionalIterator __first,
2469 _BidirectionalIterator __middle,
2470 _BidirectionalIterator __last,
2471 _Distance __len1, _Distance __len2,
2472 _Compare __comp)
2473 {
2474 if (__len1 == 0 || __len2 == 0)
2475 return;
2476
2477 if (__len1 + __len2 == 2)
2478 {
2479 if (__comp(__middle, __first))
2480 std::iter_swap(__first, __middle);
2481 return;
2482 }
2483
2484 _BidirectionalIterator __first_cut = __first;
2485 _BidirectionalIterator __second_cut = __middle;
2486 _Distance __len11 = 0;
2487 _Distance __len22 = 0;
2488 if (__len1 > __len2)
2489 {
2490 __len11 = __len1 / 2;
2491 std::advance(__first_cut, __len11);
2492 __second_cut
2493 = std::__lower_bound(__middle, __last, *__first_cut,
2494 __gnu_cxx::__ops::__iter_comp_val(__comp));
2495 __len22 = std::distance(__middle, __second_cut);
2496 }
2497 else
2498 {
2499 __len22 = __len2 / 2;
2500 std::advance(__second_cut, __len22);
2501 __first_cut
2502 = std::__upper_bound(__first, __middle, *__second_cut,
2503 __gnu_cxx::__ops::__val_comp_iter(__comp));
2504 __len11 = std::distance(__first, __first_cut);
2505 }
2506
2507 _BidirectionalIterator __new_middle
2508 = std::rotate(__first_cut, __middle, __second_cut);
2509 std::__merge_without_buffer(__first, __first_cut, __new_middle,
2510 __len11, __len22, __comp);
2511 std::__merge_without_buffer(__new_middle, __second_cut, __last,
2512 __len1 - __len11, __len2 - __len22, __comp);
2513 }
2514
2515 template<typename _BidirectionalIterator, typename _Compare>
2516 void
2517 __inplace_merge(_BidirectionalIterator __first,
2518 _BidirectionalIterator __middle,
2519 _BidirectionalIterator __last,
2520 _Compare __comp)
2521 {
2522 typedef typename iterator_traits<_BidirectionalIterator>::value_type
2523 _ValueType;
2524 typedef typename iterator_traits<_BidirectionalIterator>::difference_type
2525 _DistanceType;
2526 typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
2527
2528 if (__first == __middle || __middle == __last)
2529 return;
2530
2531 const _DistanceType __len1 = std::distance(__first, __middle);
2532 const _DistanceType __len2 = std::distance(__middle, __last);
2533
2534 // __merge_adaptive will use a buffer for the smaller of
2535 // [first,middle) and [middle,last).
2536 _TmpBuf __buf(__first, std::min(__len1, __len2));
2537
2538 if (__buf.begin() == 0)
2539 std::__merge_without_buffer
2540 (__first, __middle, __last, __len1, __len2, __comp);
2541 else
2542 std::__merge_adaptive
2543 (__first, __middle, __last, __len1, __len2, __buf.begin(),
2544 _DistanceType(__buf.size()), __comp);
2545 }
2546
2547 /**
2548 * @brief Merges two sorted ranges in place.
2549 * @ingroup sorting_algorithms
2550 * @param __first An iterator.
2551 * @param __middle Another iterator.
2552 * @param __last Another iterator.
2553 * @return Nothing.
2554 *
2555 * Merges two sorted and consecutive ranges, [__first,__middle) and
2556 * [__middle,__last), and puts the result in [__first,__last). The
2557 * output will be sorted. The sort is @e stable, that is, for
2558 * equivalent elements in the two ranges, elements from the first
2559 * range will always come before elements from the second.
2560 *
2561 * If enough additional memory is available, this takes (__last-__first)-1
2562 * comparisons. Otherwise an NlogN algorithm is used, where N is
2563 * distance(__first,__last).
2564 */
2565 template<typename _BidirectionalIterator>
2566 inline void
2567 inplace_merge(_BidirectionalIterator __first,
2568 _BidirectionalIterator __middle,
2569 _BidirectionalIterator __last)
2570 {
2571 // concept requirements
2572 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
2573 _BidirectionalIterator>)
2574 __glibcxx_function_requires(_LessThanComparableConcept<
2575 typename iterator_traits<_BidirectionalIterator>::value_type>)
2576 __glibcxx_requires_sorted(__first, __middle);
2577 __glibcxx_requires_sorted(__middle, __last);
2578 __glibcxx_requires_irreflexive(__first, __last);
2579
2580 std::__inplace_merge(__first, __middle, __last,
2581 __gnu_cxx::__ops::__iter_less_iter());
2582 }
2583
2584 /**
2585 * @brief Merges two sorted ranges in place.
2586 * @ingroup sorting_algorithms
2587 * @param __first An iterator.
2588 * @param __middle Another iterator.
2589 * @param __last Another iterator.
2590 * @param __comp A functor to use for comparisons.
2591 * @return Nothing.
2592 *
2593 * Merges two sorted and consecutive ranges, [__first,__middle) and
2594 * [middle,last), and puts the result in [__first,__last). The output will
2595 * be sorted. The sort is @e stable, that is, for equivalent
2596 * elements in the two ranges, elements from the first range will always
2597 * come before elements from the second.
2598 *
2599 * If enough additional memory is available, this takes (__last-__first)-1
2600 * comparisons. Otherwise an NlogN algorithm is used, where N is
2601 * distance(__first,__last).
2602 *
2603 * The comparison function should have the same effects on ordering as
2604 * the function used for the initial sort.
2605 */
2606 template<typename _BidirectionalIterator, typename _Compare>
2607 inline void
2608 inplace_merge(_BidirectionalIterator __first,
2609 _BidirectionalIterator __middle,
2610 _BidirectionalIterator __last,
2611 _Compare __comp)
2612 {
2613 // concept requirements
2614 __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
2615 _BidirectionalIterator>)
2616 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2617 typename iterator_traits<_BidirectionalIterator>::value_type,
2618 typename iterator_traits<_BidirectionalIterator>::value_type>)
2619 __glibcxx_requires_sorted_pred(__first, __middle, __comp);
2620 __glibcxx_requires_sorted_pred(__middle, __last, __comp);
2621 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
2622
2623 std::__inplace_merge(__first, __middle, __last,
2624 __gnu_cxx::__ops::__iter_comp_iter(__comp));
2625 }
2626
2627
2628 /// This is a helper function for the __merge_sort_loop routines.
2629 template<typename _InputIterator, typename _OutputIterator,
2630 typename _Compare>
2631 _OutputIterator
2632 __move_merge(_InputIterator __first1, _InputIterator __last1,
2633 _InputIterator __first2, _InputIterator __last2,
2634 _OutputIterator __result, _Compare __comp)
2635 {
2636 while (__first1 != __last1 && __first2 != __last2)
2637 {
2638 if (__comp(__first2, __first1))
2639 {
2640 *__result = _GLIBCXX_MOVE(*__first2);
2641 ++__first2;
2642 }
2643 else
2644 {
2645 *__result = _GLIBCXX_MOVE(*__first1);
2646 ++__first1;
2647 }
2648 ++__result;
2649 }
2650 return _GLIBCXX_MOVE3(__first2, __last2,
2651 _GLIBCXX_MOVE3(__first1, __last1,
2652 __result));
2653 }
2654
2655 template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
2656 typename _Distance, typename _Compare>
2657 void
2658 __merge_sort_loop(_RandomAccessIterator1 __first,
2659 _RandomAccessIterator1 __last,
2660 _RandomAccessIterator2 __result, _Distance __step_size,
2661 _Compare __comp)
2662 {
2663 const _Distance __two_step = 2 * __step_size;
2664
2665 while (__last - __first >= __two_step)
2666 {
2667 __result = std::__move_merge(__first, __first + __step_size,
2668 __first + __step_size,
2669 __first + __two_step,
2670 __result, __comp);
2671 __first += __two_step;
2672 }
2673 __step_size = std::min(_Distance(__last - __first), __step_size);
2674
2675 std::__move_merge(__first, __first + __step_size,
2676 __first + __step_size, __last, __result, __comp);
2677 }
2678
2679 template<typename _RandomAccessIterator, typename _Distance,
2680 typename _Compare>
2681 _GLIBCXX20_CONSTEXPR
2682 void
2683 __chunk_insertion_sort(_RandomAccessIterator __first,
2684 _RandomAccessIterator __last,
2685 _Distance __chunk_size, _Compare __comp)
2686 {
2687 while (__last - __first >= __chunk_size)
2688 {
2689 std::__insertion_sort(__first, __first + __chunk_size, __comp);
2690 __first += __chunk_size;
2691 }
2692 std::__insertion_sort(__first, __last, __comp);
2693 }
2694
2695 enum { _S_chunk_size = 7 };
2696
2697 template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
2698 void
2699 __merge_sort_with_buffer(_RandomAccessIterator __first,
2700 _RandomAccessIterator __last,
2701 _Pointer __buffer, _Compare __comp)
2702 {
2703 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
2704 _Distance;
2705
2706 const _Distance __len = __last - __first;
2707 const _Pointer __buffer_last = __buffer + __len;
2708
2709 _Distance __step_size = _S_chunk_size;
2710 std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
2711
2712 while (__step_size < __len)
2713 {
2714 std::__merge_sort_loop(__first, __last, __buffer,
2715 __step_size, __comp);
2716 __step_size *= 2;
2717 std::__merge_sort_loop(__buffer, __buffer_last, __first,
2718 __step_size, __comp);
2719 __step_size *= 2;
2720 }
2721 }
2722
2723 template<typename _RandomAccessIterator, typename _Pointer,
2724 typename _Distance, typename _Compare>
2725 void
2726 __stable_sort_adaptive(_RandomAccessIterator __first,
2727 _RandomAccessIterator __last,
2728 _Pointer __buffer, _Distance __buffer_size,
2729 _Compare __comp)
2730 {
2731 const _Distance __len = (__last - __first + 1) / 2;
2732 const _RandomAccessIterator __middle = __first + __len;
2733 if (__len > __buffer_size)
2734 {
2735 std::__stable_sort_adaptive(__first, __middle, __buffer,
2736 __buffer_size, __comp);
2737 std::__stable_sort_adaptive(__middle, __last, __buffer,
2738 __buffer_size, __comp);
2739 }
2740 else
2741 {
2742 std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
2743 std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
2744 }
2745
2746 std::__merge_adaptive(__first, __middle, __last,
2747 _Distance(__middle - __first),
2748 _Distance(__last - __middle),
2749 __buffer, __buffer_size,
2750 __comp);
2751 }
2752
2753 /// This is a helper function for the stable sorting routines.
2754 template<typename _RandomAccessIterator, typename _Compare>
2755 void
2756 __inplace_stable_sort(_RandomAccessIterator __first,
2757 _RandomAccessIterator __last, _Compare __comp)
2758 {
2759 if (__last - __first < 15)
2760 {
2761 std::__insertion_sort(__first, __last, __comp);
2762 return;
2763 }
2764 _RandomAccessIterator __middle = __first + (__last - __first) / 2;
2765 std::__inplace_stable_sort(__first, __middle, __comp);
2766 std::__inplace_stable_sort(__middle, __last, __comp);
2767 std::__merge_without_buffer(__first, __middle, __last,
2768 __middle - __first,
2769 __last - __middle,
2770 __comp);
2771 }
2772
2773 // stable_sort
2774
2775 // Set algorithms: includes, set_union, set_intersection, set_difference,
2776 // set_symmetric_difference. All of these algorithms have the precondition
2777 // that their input ranges are sorted and the postcondition that their output
2778 // ranges are sorted.
2779
2780 template<typename _InputIterator1, typename _InputIterator2,
2781 typename _Compare>
2782 _GLIBCXX20_CONSTEXPR
2783 bool
2784 __includes(_InputIterator1 __first1, _InputIterator1 __last1,
2785 _InputIterator2 __first2, _InputIterator2 __last2,
2786 _Compare __comp)
2787 {
2788 while (__first1 != __last1 && __first2 != __last2)
2789 {
2790 if (__comp(__first2, __first1))
2791 return false;
2792 if (!__comp(__first1, __first2))
2793 ++__first2;
2794 ++__first1;
2795 }
2796
2797 return __first2 == __last2;
2798 }
2799
2800 /**
2801 * @brief Determines whether all elements of a sequence exists in a range.
2802 * @param __first1 Start of search range.
2803 * @param __last1 End of search range.
2804 * @param __first2 Start of sequence
2805 * @param __last2 End of sequence.
2806 * @return True if each element in [__first2,__last2) is contained in order
2807 * within [__first1,__last1). False otherwise.
2808 * @ingroup set_algorithms
2809 *
2810 * This operation expects both [__first1,__last1) and
2811 * [__first2,__last2) to be sorted. Searches for the presence of
2812 * each element in [__first2,__last2) within [__first1,__last1).
2813 * The iterators over each range only move forward, so this is a
2814 * linear algorithm. If an element in [__first2,__last2) is not
2815 * found before the search iterator reaches @p __last2, false is
2816 * returned.
2817 */
2818 template<typename _InputIterator1, typename _InputIterator2>
2819 _GLIBCXX20_CONSTEXPR
2820 inline bool
2821 includes(_InputIterator1 __first1, _InputIterator1 __last1,
2822 _InputIterator2 __first2, _InputIterator2 __last2)
2823 {
2824 // concept requirements
2825 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
2826 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
2827 __glibcxx_function_requires(_LessThanOpConcept<
2828 typename iterator_traits<_InputIterator1>::value_type,
2829 typename iterator_traits<_InputIterator2>::value_type>)
2830 __glibcxx_function_requires(_LessThanOpConcept<
2831 typename iterator_traits<_InputIterator2>::value_type,
2832 typename iterator_traits<_InputIterator1>::value_type>)
2833 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
2834 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
2835 __glibcxx_requires_irreflexive2(__first1, __last1);
2836 __glibcxx_requires_irreflexive2(__first2, __last2);
2837
2838 return std::__includes(__first1, __last1, __first2, __last2,
2839 __gnu_cxx::__ops::__iter_less_iter());
2840 }
2841
2842 /**
2843 * @brief Determines whether all elements of a sequence exists in a range
2844 * using comparison.
2845 * @ingroup set_algorithms
2846 * @param __first1 Start of search range.
2847 * @param __last1 End of search range.
2848 * @param __first2 Start of sequence
2849 * @param __last2 End of sequence.
2850 * @param __comp Comparison function to use.
2851 * @return True if each element in [__first2,__last2) is contained
2852 * in order within [__first1,__last1) according to comp. False
2853 * otherwise. @ingroup set_algorithms
2854 *
2855 * This operation expects both [__first1,__last1) and
2856 * [__first2,__last2) to be sorted. Searches for the presence of
2857 * each element in [__first2,__last2) within [__first1,__last1),
2858 * using comp to decide. The iterators over each range only move
2859 * forward, so this is a linear algorithm. If an element in
2860 * [__first2,__last2) is not found before the search iterator
2861 * reaches @p __last2, false is returned.
2862 */
2863 template<typename _InputIterator1, typename _InputIterator2,
2864 typename _Compare>
2865 _GLIBCXX20_CONSTEXPR
2866 inline bool
2867 includes(_InputIterator1 __first1, _InputIterator1 __last1,
2868 _InputIterator2 __first2, _InputIterator2 __last2,
2869 _Compare __comp)
2870 {
2871 // concept requirements
2872 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
2873 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
2874 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2875 typename iterator_traits<_InputIterator1>::value_type,
2876 typename iterator_traits<_InputIterator2>::value_type>)
2877 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2878 typename iterator_traits<_InputIterator2>::value_type,
2879 typename iterator_traits<_InputIterator1>::value_type>)
2880 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
2881 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
2882 __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
2883 __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
2884
2885 return std::__includes(__first1, __last1, __first2, __last2,
2886 __gnu_cxx::__ops::__iter_comp_iter(__comp));
2887 }
2888
2889 // nth_element
2890 // merge
2891 // set_difference
2892 // set_intersection
2893 // set_union
2894 // stable_sort
2895 // set_symmetric_difference
2896 // min_element
2897 // max_element
2898
2899 template<typename _BidirectionalIterator, typename _Compare>
2900 _GLIBCXX20_CONSTEXPR
2901 bool
2902 __next_permutation(_BidirectionalIterator __first,
2903 _BidirectionalIterator __last, _Compare __comp)
2904 {
2905 if (__first == __last)
2906 return false;
2907 _BidirectionalIterator __i = __first;
2908 ++__i;
2909 if (__i == __last)
2910 return false;
2911 __i = __last;
2912 --__i;
2913
2914 for(;;)
2915 {
2916 _BidirectionalIterator __ii = __i;
2917 --__i;
2918 if (__comp(__i, __ii))
2919 {
2920 _BidirectionalIterator __j = __last;
2921 while (!__comp(__i, --__j))
2922 {}
2923 std::iter_swap(__i, __j);
2924 std::__reverse(__ii, __last,
2925 std::__iterator_category(__first));
2926 return true;
2927 }
2928 if (__i == __first)
2929 {
2930 std::__reverse(__first, __last,
2931 std::__iterator_category(__first));
2932 return false;
2933 }
2934 }
2935 }
2936
2937 /**
2938 * @brief Permute range into the next @e dictionary ordering.
2939 * @ingroup sorting_algorithms
2940 * @param __first Start of range.
2941 * @param __last End of range.
2942 * @return False if wrapped to first permutation, true otherwise.
2943 *
2944 * Treats all permutations of the range as a set of @e dictionary sorted
2945 * sequences. Permutes the current sequence into the next one of this set.
2946 * Returns true if there are more sequences to generate. If the sequence
2947 * is the largest of the set, the smallest is generated and false returned.
2948 */
2949 template<typename _BidirectionalIterator>
2950 _GLIBCXX20_CONSTEXPR
2951 inline bool
2952 next_permutation(_BidirectionalIterator __first,
2953 _BidirectionalIterator __last)
2954 {
2955 // concept requirements
2956 __glibcxx_function_requires(_BidirectionalIteratorConcept<
2957 _BidirectionalIterator>)
2958 __glibcxx_function_requires(_LessThanComparableConcept<
2959 typename iterator_traits<_BidirectionalIterator>::value_type>)
2960 __glibcxx_requires_valid_range(__first, __last);
2961 __glibcxx_requires_irreflexive(__first, __last);
2962
2963 return std::__next_permutation
2964 (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
2965 }
2966
2967 /**
2968 * @brief Permute range into the next @e dictionary ordering using
2969 * comparison functor.
2970 * @ingroup sorting_algorithms
2971 * @param __first Start of range.
2972 * @param __last End of range.
2973 * @param __comp A comparison functor.
2974 * @return False if wrapped to first permutation, true otherwise.
2975 *
2976 * Treats all permutations of the range [__first,__last) as a set of
2977 * @e dictionary sorted sequences ordered by @p __comp. Permutes the current
2978 * sequence into the next one of this set. Returns true if there are more
2979 * sequences to generate. If the sequence is the largest of the set, the
2980 * smallest is generated and false returned.
2981 */
2982 template<typename _BidirectionalIterator, typename _Compare>
2983 _GLIBCXX20_CONSTEXPR
2984 inline bool
2985 next_permutation(_BidirectionalIterator __first,
2986 _BidirectionalIterator __last, _Compare __comp)
2987 {
2988 // concept requirements
2989 __glibcxx_function_requires(_BidirectionalIteratorConcept<
2990 _BidirectionalIterator>)
2991 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
2992 typename iterator_traits<_BidirectionalIterator>::value_type,
2993 typename iterator_traits<_BidirectionalIterator>::value_type>)
2994 __glibcxx_requires_valid_range(__first, __last);
2995 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
2996
2997 return std::__next_permutation
2998 (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
2999 }
3000
3001 template<typename _BidirectionalIterator, typename _Compare>
3002 _GLIBCXX20_CONSTEXPR
3003 bool
3004 __prev_permutation(_BidirectionalIterator __first,
3005 _BidirectionalIterator __last, _Compare __comp)
3006 {
3007 if (__first == __last)
3008 return false;
3009 _BidirectionalIterator __i = __first;
3010 ++__i;
3011 if (__i == __last)
3012 return false;
3013 __i = __last;
3014 --__i;
3015
3016 for(;;)
3017 {
3018 _BidirectionalIterator __ii = __i;
3019 --__i;
3020 if (__comp(__ii, __i))
3021 {
3022 _BidirectionalIterator __j = __last;
3023 while (!__comp(--__j, __i))
3024 {}
3025 std::iter_swap(__i, __j);
3026 std::__reverse(__ii, __last,
3027 std::__iterator_category(__first));
3028 return true;
3029 }
3030 if (__i == __first)
3031 {
3032 std::__reverse(__first, __last,
3033 std::__iterator_category(__first));
3034 return false;
3035 }
3036 }
3037 }
3038
3039 /**
3040 * @brief Permute range into the previous @e dictionary ordering.
3041 * @ingroup sorting_algorithms
3042 * @param __first Start of range.
3043 * @param __last End of range.
3044 * @return False if wrapped to last permutation, true otherwise.
3045 *
3046 * Treats all permutations of the range as a set of @e dictionary sorted
3047 * sequences. Permutes the current sequence into the previous one of this
3048 * set. Returns true if there are more sequences to generate. If the
3049 * sequence is the smallest of the set, the largest is generated and false
3050 * returned.
3051 */
3052 template<typename _BidirectionalIterator>
3053 _GLIBCXX20_CONSTEXPR
3054 inline bool
3055 prev_permutation(_BidirectionalIterator __first,
3056 _BidirectionalIterator __last)
3057 {
3058 // concept requirements
3059 __glibcxx_function_requires(_BidirectionalIteratorConcept<
3060 _BidirectionalIterator>)
3061 __glibcxx_function_requires(_LessThanComparableConcept<
3062 typename iterator_traits<_BidirectionalIterator>::value_type>)
3063 __glibcxx_requires_valid_range(__first, __last);
3064 __glibcxx_requires_irreflexive(__first, __last);
3065
3066 return std::__prev_permutation(__first, __last,
3067 __gnu_cxx::__ops::__iter_less_iter());
3068 }
3069
3070 /**
3071 * @brief Permute range into the previous @e dictionary ordering using
3072 * comparison functor.
3073 * @ingroup sorting_algorithms
3074 * @param __first Start of range.
3075 * @param __last End of range.
3076 * @param __comp A comparison functor.
3077 * @return False if wrapped to last permutation, true otherwise.
3078 *
3079 * Treats all permutations of the range [__first,__last) as a set of
3080 * @e dictionary sorted sequences ordered by @p __comp. Permutes the current
3081 * sequence into the previous one of this set. Returns true if there are
3082 * more sequences to generate. If the sequence is the smallest of the set,
3083 * the largest is generated and false returned.
3084 */
3085 template<typename _BidirectionalIterator, typename _Compare>
3086 _GLIBCXX20_CONSTEXPR
3087 inline bool
3088 prev_permutation(_BidirectionalIterator __first,
3089 _BidirectionalIterator __last, _Compare __comp)
3090 {
3091 // concept requirements
3092 __glibcxx_function_requires(_BidirectionalIteratorConcept<
3093 _BidirectionalIterator>)
3094 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
3095 typename iterator_traits<_BidirectionalIterator>::value_type,
3096 typename iterator_traits<_BidirectionalIterator>::value_type>)
3097 __glibcxx_requires_valid_range(__first, __last);
3098 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
3099
3100 return std::__prev_permutation(__first, __last,
3101 __gnu_cxx::__ops::__iter_comp_iter(__comp));
3102 }
3103
3104 // replace
3105 // replace_if
3106
3107 template<typename _InputIterator, typename _OutputIterator,
3108 typename _Predicate, typename _Tp>
3109 _GLIBCXX20_CONSTEXPR
3110 _OutputIterator
3111 __replace_copy_if(_InputIterator __first, _InputIterator __last,
3112 _OutputIterator __result,
3113 _Predicate __pred, const _Tp& __new_value)
3114 {
3115 for (; __first != __last; ++__first, (void)++__result)
3116 if (__pred(__first))
3117 *__result = __new_value;
3118 else
3119 *__result = *__first;
3120 return __result;
3121 }
3122
3123 /**
3124 * @brief Copy a sequence, replacing each element of one value with another
3125 * value.
3126 * @param __first An input iterator.
3127 * @param __last An input iterator.
3128 * @param __result An output iterator.
3129 * @param __old_value The value to be replaced.
3130 * @param __new_value The replacement value.
3131 * @return The end of the output sequence, @p result+(last-first).
3132 *
3133 * Copies each element in the input range @p [__first,__last) to the
3134 * output range @p [__result,__result+(__last-__first)) replacing elements
3135 * equal to @p __old_value with @p __new_value.
3136 */
3137 template<typename _InputIterator, typename _OutputIterator, typename _Tp>
3138 _GLIBCXX20_CONSTEXPR
3139 inline _OutputIterator
3140 replace_copy(_InputIterator __first, _InputIterator __last,
3141 _OutputIterator __result,
3142 const _Tp& __old_value, const _Tp& __new_value)
3143 {
3144 // concept requirements
3145 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3146 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
3147 typename iterator_traits<_InputIterator>::value_type>)
3148 __glibcxx_function_requires(_EqualOpConcept<
3149 typename iterator_traits<_InputIterator>::value_type, _Tp>)
3150 __glibcxx_requires_valid_range(__first, __last);
3151
3152 return std::__replace_copy_if(__first, __last, __result,
3153 __gnu_cxx::__ops::__iter_equals_val(__old_value),
3154 __new_value);
3155 }
3156
3157 /**
3158 * @brief Copy a sequence, replacing each value for which a predicate
3159 * returns true with another value.
3160 * @ingroup mutating_algorithms
3161 * @param __first An input iterator.
3162 * @param __last An input iterator.
3163 * @param __result An output iterator.
3164 * @param __pred A predicate.
3165 * @param __new_value The replacement value.
3166 * @return The end of the output sequence, @p __result+(__last-__first).
3167 *
3168 * Copies each element in the range @p [__first,__last) to the range
3169 * @p [__result,__result+(__last-__first)) replacing elements for which
3170 * @p __pred returns true with @p __new_value.
3171 */
3172 template<typename _InputIterator, typename _OutputIterator,
3173 typename _Predicate, typename _Tp>
3174 _GLIBCXX20_CONSTEXPR
3175 inline _OutputIterator
3176 replace_copy_if(_InputIterator __first, _InputIterator __last,
3177 _OutputIterator __result,
3178 _Predicate __pred, const _Tp& __new_value)
3179 {
3180 // concept requirements
3181 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3182 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
3183 typename iterator_traits<_InputIterator>::value_type>)
3184 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
3185 typename iterator_traits<_InputIterator>::value_type>)
3186 __glibcxx_requires_valid_range(__first, __last);
3187
3188 return std::__replace_copy_if(__first, __last, __result,
3189 __gnu_cxx::__ops::__pred_iter(__pred),
3190 __new_value);
3191 }
3192
3193#if __cplusplus >= 201103L
3194 /**
3195 * @brief Determines whether the elements of a sequence are sorted.
3196 * @ingroup sorting_algorithms
3197 * @param __first An iterator.
3198 * @param __last Another iterator.
3199 * @return True if the elements are sorted, false otherwise.
3200 */
3201 template<typename _ForwardIterator>
3202 _GLIBCXX20_CONSTEXPR
3203 inline bool
3204 is_sorted(_ForwardIterator __first, _ForwardIterator __last)
3205 { return std::is_sorted_until(__first, __last) == __last; }
3206
3207 /**
3208 * @brief Determines whether the elements of a sequence are sorted
3209 * according to a comparison functor.
3210 * @ingroup sorting_algorithms
3211 * @param __first An iterator.
3212 * @param __last Another iterator.
3213 * @param __comp A comparison functor.
3214 * @return True if the elements are sorted, false otherwise.
3215 */
3216 template<typename _ForwardIterator, typename _Compare>
3217 _GLIBCXX20_CONSTEXPR
3218 inline bool
3219 is_sorted(_ForwardIterator __first, _ForwardIterator __last,
3220 _Compare __comp)
3221 { return std::is_sorted_until(__first, __last, __comp) == __last; }
3222
3223 template<typename _ForwardIterator, typename _Compare>
3224 _GLIBCXX20_CONSTEXPR
3225 _ForwardIterator
3226 __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
3227 _Compare __comp)
3228 {
3229 if (__first == __last)
3230 return __last;
3231
3232 _ForwardIterator __next = __first;
3233 for (++__next; __next != __last; __first = __next, (void)++__next)
3234 if (__comp(__next, __first))
3235 return __next;
3236 return __next;
3237 }
3238
3239 /**
3240 * @brief Determines the end of a sorted sequence.
3241 * @ingroup sorting_algorithms
3242 * @param __first An iterator.
3243 * @param __last Another iterator.
3244 * @return An iterator pointing to the last iterator i in [__first, __last)
3245 * for which the range [__first, i) is sorted.
3246 */
3247 template<typename _ForwardIterator>
3248 _GLIBCXX20_CONSTEXPR
3249 inline _ForwardIterator
3250 is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
3251 {
3252 // concept requirements
3253 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3254 __glibcxx_function_requires(_LessThanComparableConcept<
3255 typename iterator_traits<_ForwardIterator>::value_type>)
3256 __glibcxx_requires_valid_range(__first, __last);
3257 __glibcxx_requires_irreflexive(__first, __last);
3258
3259 return std::__is_sorted_until(__first, __last,
3260 __gnu_cxx::__ops::__iter_less_iter());
3261 }
3262
3263 /**
3264 * @brief Determines the end of a sorted sequence using comparison functor.
3265 * @ingroup sorting_algorithms
3266 * @param __first An iterator.
3267 * @param __last Another iterator.
3268 * @param __comp A comparison functor.
3269 * @return An iterator pointing to the last iterator i in [__first, __last)
3270 * for which the range [__first, i) is sorted.
3271 */
3272 template<typename _ForwardIterator, typename _Compare>
3273 _GLIBCXX20_CONSTEXPR
3274 inline _ForwardIterator
3275 is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
3276 _Compare __comp)
3277 {
3278 // concept requirements
3279 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3280 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
3281 typename iterator_traits<_ForwardIterator>::value_type,
3282 typename iterator_traits<_ForwardIterator>::value_type>)
3283 __glibcxx_requires_valid_range(__first, __last);
3284 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
3285
3286 return std::__is_sorted_until(__first, __last,
3287 __gnu_cxx::__ops::__iter_comp_iter(__comp));
3288 }
3289
3290 /**
3291 * @brief Determines min and max at once as an ordered pair.
3292 * @ingroup sorting_algorithms
3293 * @param __a A thing of arbitrary type.
3294 * @param __b Another thing of arbitrary type.
3295 * @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
3296 * __b) otherwise.
3297 */
3298 template<typename _Tp>
3299 _GLIBCXX14_CONSTEXPR
3300 inline pair<const _Tp&, const _Tp&>
3301 minmax(const _Tp& __a, const _Tp& __b)
3302 {
3303 // concept requirements
3304 __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
3305
3306 return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
3307 : pair<const _Tp&, const _Tp&>(__a, __b);
3308 }
3309
3310 /**
3311 * @brief Determines min and max at once as an ordered pair.
3312 * @ingroup sorting_algorithms
3313 * @param __a A thing of arbitrary type.
3314 * @param __b Another thing of arbitrary type.
3315 * @param __comp A @link comparison_functors comparison functor @endlink.
3316 * @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
3317 * __b) otherwise.
3318 */
3319 template<typename _Tp, typename _Compare>
3320 _GLIBCXX14_CONSTEXPR
3321 inline pair<const _Tp&, const _Tp&>
3322 minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
3323 {
3324 return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
3325 : pair<const _Tp&, const _Tp&>(__a, __b);
3326 }
3327
3328 template<typename _ForwardIterator, typename _Compare>
3329 _GLIBCXX14_CONSTEXPR
3330 pair<_ForwardIterator, _ForwardIterator>
3331 __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
3332 _Compare __comp)
3333 {
3334 _ForwardIterator __next = __first;
3335 if (__first == __last
3336 || ++__next == __last)
3337 return std::make_pair(__first, __first);
3338
3339 _ForwardIterator __min{}, __max{};
3340 if (__comp(__next, __first))
3341 {
3342 __min = __next;
3343 __max = __first;
3344 }
3345 else
3346 {
3347 __min = __first;
3348 __max = __next;
3349 }
3350
3351 __first = __next;
3352 ++__first;
3353
3354 while (__first != __last)
3355 {
3356 __next = __first;
3357 if (++__next == __last)
3358 {
3359 if (__comp(__first, __min))
3360 __min = __first;
3361 else if (!__comp(__first, __max))
3362 __max = __first;
3363 break;
3364 }
3365
3366 if (__comp(__next, __first))
3367 {
3368 if (__comp(__next, __min))
3369 __min = __next;
3370 if (!__comp(__first, __max))
3371 __max = __first;
3372 }
3373 else
3374 {
3375 if (__comp(__first, __min))
3376 __min = __first;
3377 if (!__comp(__next, __max))
3378 __max = __next;
3379 }
3380
3381 __first = __next;
3382 ++__first;
3383 }
3384
3385 return std::make_pair(__min, __max);
3386 }
3387
3388 /**
3389 * @brief Return a pair of iterators pointing to the minimum and maximum
3390 * elements in a range.
3391 * @ingroup sorting_algorithms
3392 * @param __first Start of range.
3393 * @param __last End of range.
3394 * @return make_pair(m, M), where m is the first iterator i in
3395 * [__first, __last) such that no other element in the range is
3396 * smaller, and where M is the last iterator i in [__first, __last)
3397 * such that no other element in the range is larger.
3398 */
3399 template<typename _ForwardIterator>
3400 _GLIBCXX14_CONSTEXPR
3401 inline pair<_ForwardIterator, _ForwardIterator>
3402 minmax_element(_ForwardIterator __first, _ForwardIterator __last)
3403 {
3404 // concept requirements
3405 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3406 __glibcxx_function_requires(_LessThanComparableConcept<
3407 typename iterator_traits<_ForwardIterator>::value_type>)
3408 __glibcxx_requires_valid_range(__first, __last);
3409 __glibcxx_requires_irreflexive(__first, __last);
3410
3411 return std::__minmax_element(__first, __last,
3412 __gnu_cxx::__ops::__iter_less_iter());
3413 }
3414
3415 /**
3416 * @brief Return a pair of iterators pointing to the minimum and maximum
3417 * elements in a range.
3418 * @ingroup sorting_algorithms
3419 * @param __first Start of range.
3420 * @param __last End of range.
3421 * @param __comp Comparison functor.
3422 * @return make_pair(m, M), where m is the first iterator i in
3423 * [__first, __last) such that no other element in the range is
3424 * smaller, and where M is the last iterator i in [__first, __last)
3425 * such that no other element in the range is larger.
3426 */
3427 template<typename _ForwardIterator, typename _Compare>
3428 _GLIBCXX14_CONSTEXPR
3429 inline pair<_ForwardIterator, _ForwardIterator>
3430 minmax_element(_ForwardIterator __first, _ForwardIterator __last,
3431 _Compare __comp)
3432 {
3433 // concept requirements
3434 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3435 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
3436 typename iterator_traits<_ForwardIterator>::value_type,
3437 typename iterator_traits<_ForwardIterator>::value_type>)
3438 __glibcxx_requires_valid_range(__first, __last);
3439 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
3440
3441 return std::__minmax_element(__first, __last,
3442 __gnu_cxx::__ops::__iter_comp_iter(__comp));
3443 }
3444
3445 // N2722 + DR 915.
3446 template<typename _Tp>
3447 _GLIBCXX14_CONSTEXPR
3448 inline _Tp
3449 min(initializer_list<_Tp> __l)
3450 { return *std::min_element(__l.begin(), __l.end()); }
3451
3452 template<typename _Tp, typename _Compare>
3453 _GLIBCXX14_CONSTEXPR
3454 inline _Tp
3455 min(initializer_list<_Tp> __l, _Compare __comp)
3456 { return *std::min_element(__l.begin(), __l.end(), __comp); }
3457
3458 template<typename _Tp>
3459 _GLIBCXX14_CONSTEXPR
3460 inline _Tp
3461 max(initializer_list<_Tp> __l)
3462 { return *std::max_element(__l.begin(), __l.end()); }
3463
3464 template<typename _Tp, typename _Compare>
3465 _GLIBCXX14_CONSTEXPR
3466 inline _Tp
3467 max(initializer_list<_Tp> __l, _Compare __comp)
3468 { return *std::max_element(__l.begin(), __l.end(), __comp); }
3469
3470 template<typename _Tp>
3471 _GLIBCXX14_CONSTEXPR
3472 inline pair<_Tp, _Tp>
3473 minmax(initializer_list<_Tp> __l)
3474 {
3475 pair<const _Tp*, const _Tp*> __p =
3476 std::minmax_element(__l.begin(), __l.end());
3477 return std::make_pair(*__p.first, *__p.second);
3478 }
3479
3480 template<typename _Tp, typename _Compare>
3481 _GLIBCXX14_CONSTEXPR
3482 inline pair<_Tp, _Tp>
3483 minmax(initializer_list<_Tp> __l, _Compare __comp)
3484 {
3485 pair<const _Tp*, const _Tp*> __p =
3486 std::minmax_element(__l.begin(), __l.end(), __comp);
3487 return std::make_pair(*__p.first, *__p.second);
3488 }
3489
3490 /**
3491 * @brief Checks whether a permutation of the second sequence is equal
3492 * to the first sequence.
3493 * @ingroup non_mutating_algorithms
3494 * @param __first1 Start of first range.
3495 * @param __last1 End of first range.
3496 * @param __first2 Start of second range.
3497 * @param __pred A binary predicate.
3498 * @return true if there exists a permutation of the elements in
3499 * the range [__first2, __first2 + (__last1 - __first1)),
3500 * beginning with ForwardIterator2 begin, such that
3501 * equal(__first1, __last1, __begin, __pred) returns true;
3502 * otherwise, returns false.
3503 */
3504 template<typename _ForwardIterator1, typename _ForwardIterator2,
3505 typename _BinaryPredicate>
3506 _GLIBCXX20_CONSTEXPR
3507 inline bool
3508 is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
3509 _ForwardIterator2 __first2, _BinaryPredicate __pred)
3510 {
3511 // concept requirements
3512 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
3513 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
3514 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
3515 typename iterator_traits<_ForwardIterator1>::value_type,
3516 typename iterator_traits<_ForwardIterator2>::value_type>)
3517 __glibcxx_requires_valid_range(__first1, __last1);
3518
3519 return std::__is_permutation(__first1, __last1, __first2,
3520 __gnu_cxx::__ops::__iter_comp_iter(__pred));
3521 }
3522
3523#if __cplusplus > 201103L
3524 template<typename _ForwardIterator1, typename _ForwardIterator2,
3525 typename _BinaryPredicate>
3526 _GLIBCXX20_CONSTEXPR
3527 bool
3528 __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
3529 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
3530 _BinaryPredicate __pred)
3531 {
3532 using _Cat1
3533 = typename iterator_traits<_ForwardIterator1>::iterator_category;
3534 using _Cat2
3535 = typename iterator_traits<_ForwardIterator2>::iterator_category;
3536 using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
3537 using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
3538 constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
3539 if (__ra_iters)
3540 {
3541 auto __d1 = std::distance(__first1, __last1);
3542 auto __d2 = std::distance(__first2, __last2);
3543 if (__d1 != __d2)
3544 return false;
3545 }
3546
3547 // Efficiently compare identical prefixes: O(N) if sequences
3548 // have the same elements in the same order.
3549 for (; __first1 != __last1 && __first2 != __last2;
3550 ++__first1, (void)++__first2)
3551 if (!__pred(__first1, __first2))
3552 break;
3553
3554 if (__ra_iters)
3555 {
3556 if (__first1 == __last1)
3557 return true;
3558 }
3559 else
3560 {
3561 auto __d1 = std::distance(__first1, __last1);
3562 auto __d2 = std::distance(__first2, __last2);
3563 if (__d1 == 0 && __d2 == 0)
3564 return true;
3565 if (__d1 != __d2)
3566 return false;
3567 }
3568
3569 for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
3570 {
3571 if (__scan != std::__find_if(__first1, __scan,
3572 __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
3573 continue; // We've seen this one before.
3574
3575 auto __matches = std::__count_if(__first2, __last2,
3576 __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
3577 if (0 == __matches
3578 || std::__count_if(__scan, __last1,
3579 __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
3580 != __matches)
3581 return false;
3582 }
3583 return true;
3584 }
3585
3586 /**
3587 * @brief Checks whether a permutaion of the second sequence is equal
3588 * to the first sequence.
3589 * @ingroup non_mutating_algorithms
3590 * @param __first1 Start of first range.
3591 * @param __last1 End of first range.
3592 * @param __first2 Start of second range.
3593 * @param __last2 End of first range.
3594 * @return true if there exists a permutation of the elements in the range
3595 * [__first2, __last2), beginning with ForwardIterator2 begin,
3596 * such that equal(__first1, __last1, begin) returns true;
3597 * otherwise, returns false.
3598 */
3599 template<typename _ForwardIterator1, typename _ForwardIterator2>
3600 _GLIBCXX20_CONSTEXPR
3601 inline bool
3602 is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
3603 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
3604 {
3605 __glibcxx_requires_valid_range(__first1, __last1);
3606 __glibcxx_requires_valid_range(__first2, __last2);
3607
3608 return
3609 std::__is_permutation(__first1, __last1, __first2, __last2,
3610 __gnu_cxx::__ops::__iter_equal_to_iter());
3611 }
3612
3613 /**
3614 * @brief Checks whether a permutation of the second sequence is equal
3615 * to the first sequence.
3616 * @ingroup non_mutating_algorithms
3617 * @param __first1 Start of first range.
3618 * @param __last1 End of first range.
3619 * @param __first2 Start of second range.
3620 * @param __last2 End of first range.
3621 * @param __pred A binary predicate.
3622 * @return true if there exists a permutation of the elements in the range
3623 * [__first2, __last2), beginning with ForwardIterator2 begin,
3624 * such that equal(__first1, __last1, __begin, __pred) returns true;
3625 * otherwise, returns false.
3626 */
3627 template<typename _ForwardIterator1, typename _ForwardIterator2,
3628 typename _BinaryPredicate>
3629 _GLIBCXX20_CONSTEXPR
3630 inline bool
3631 is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
3632 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
3633 _BinaryPredicate __pred)
3634 {
3635 __glibcxx_requires_valid_range(__first1, __last1);
3636 __glibcxx_requires_valid_range(__first2, __last2);
3637
3638 return std::__is_permutation(__first1, __last1, __first2, __last2,
3639 __gnu_cxx::__ops::__iter_comp_iter(__pred));
3640 }
3641
3642#if __cplusplus > 201402L
3643
3644#define __cpp_lib_clamp 201603
3645
3646 /**
3647 * @brief Returns the value clamped between lo and hi.
3648 * @ingroup sorting_algorithms
3649 * @param __val A value of arbitrary type.
3650 * @param __lo A lower limit of arbitrary type.
3651 * @param __hi An upper limit of arbitrary type.
3652 * @return max(__val, __lo) if __val < __hi or min(__val, __hi) otherwise.
3653 */
3654 template<typename _Tp>
3655 constexpr const _Tp&
3656 clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
3657 {
3658 __glibcxx_assert(!(__hi < __lo));
3659 return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
3660 }
3661
3662 /**
3663 * @brief Returns the value clamped between lo and hi.
3664 * @ingroup sorting_algorithms
3665 * @param __val A value of arbitrary type.
3666 * @param __lo A lower limit of arbitrary type.
3667 * @param __hi An upper limit of arbitrary type.
3668 * @param __comp A comparison functor.
3669 * @return max(__val, __lo, __comp) if __comp(__val, __hi)
3670 * or min(__val, __hi, __comp) otherwise.
3671 */
3672 template<typename _Tp, typename _Compare>
3673 constexpr const _Tp&
3674 clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
3675 {
3676 __glibcxx_assert(!__comp(__hi, __lo));
3677 return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
3678 }
3679#endif // C++17
3680#endif // C++14
3681
3682#ifdef _GLIBCXX_USE_C99_STDINT_TR1
3683 /**
3684 * @brief Generate two uniformly distributed integers using a
3685 * single distribution invocation.
3686 * @param __b0 The upper bound for the first integer.
3687 * @param __b1 The upper bound for the second integer.
3688 * @param __g A UniformRandomBitGenerator.
3689 * @return A pair (i, j) with i and j uniformly distributed
3690 * over [0, __b0) and [0, __b1), respectively.
3691 *
3692 * Requires: __b0 * __b1 <= __g.max() - __g.min().
3693 *
3694 * Using uniform_int_distribution with a range that is very
3695 * small relative to the range of the generator ends up wasting
3696 * potentially expensively generated randomness, since
3697 * uniform_int_distribution does not store leftover randomness
3698 * between invocations.
3699 *
3700 * If we know we want two integers in ranges that are sufficiently
3701 * small, we can compose the ranges, use a single distribution
3702 * invocation, and significantly reduce the waste.
3703 */
3704 template<typename _IntType, typename _UniformRandomBitGenerator>
3705 pair<_IntType, _IntType>
3706 __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
3707 _UniformRandomBitGenerator&& __g)
3708 {
3709 _IntType __x
3710 = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
3711 return std::make_pair(__x / __b1, __x % __b1);
3712 }
3713
3714 /**
3715 * @brief Shuffle the elements of a sequence using a uniform random
3716 * number generator.
3717 * @ingroup mutating_algorithms
3718 * @param __first A forward iterator.
3719 * @param __last A forward iterator.
3720 * @param __g A UniformRandomNumberGenerator (26.5.1.3).
3721 * @return Nothing.
3722 *
3723 * Reorders the elements in the range @p [__first,__last) using @p __g to
3724 * provide random numbers.
3725 */
3726 template<typename _RandomAccessIterator,
3727 typename _UniformRandomNumberGenerator>
3728 void
3729 shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
3730 _UniformRandomNumberGenerator&& __g)
3731 {
3732 // concept requirements
3733 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
3734 _RandomAccessIterator>)
3735 __glibcxx_requires_valid_range(__first, __last);
3736
3737 if (__first == __last)
3738 return;
3739
3740 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
3741 _DistanceType;
3742
3743 typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
3744 typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
3745 typedef typename __distr_type::param_type __p_type;
3746
3747 typedef typename remove_reference<_UniformRandomNumberGenerator>::type
3748 _Gen;
3749 typedef typename common_type<typename _Gen::result_type, __ud_type>::type
3750 __uc_type;
3751
3752 const __uc_type __urngrange = __g.max() - __g.min();
3753 const __uc_type __urange = __uc_type(__last - __first);
3754
3755 if (__urngrange / __urange >= __urange)
3756 // I.e. (__urngrange >= __urange * __urange) but without wrap issues.
3757 {
3758 _RandomAccessIterator __i = __first + 1;
3759
3760 // Since we know the range isn't empty, an even number of elements
3761 // means an uneven number of elements /to swap/, in which case we
3762 // do the first one up front:
3763
3764 if ((__urange % 2) == 0)
3765 {
3766 __distr_type __d{0, 1};
3767 std::iter_swap(__i++, __first + __d(__g));
3768 }
3769
3770 // Now we know that __last - __i is even, so we do the rest in pairs,
3771 // using a single distribution invocation to produce swap positions
3772 // for two successive elements at a time:
3773
3774 while (__i != __last)
3775 {
3776 const __uc_type __swap_range = __uc_type(__i - __first) + 1;
3777
3778 const pair<__uc_type, __uc_type> __pospos =
3779 __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);
3780
3781 std::iter_swap(__i++, __first + __pospos.first);
3782 std::iter_swap(__i++, __first + __pospos.second);
3783 }
3784
3785 return;
3786 }
3787
3788 __distr_type __d;
3789
3790 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
3791 std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
3792 }
3793#endif
3794
3795#endif // C++11
3796
3797_GLIBCXX_BEGIN_NAMESPACE_ALGO
3798
3799 /**
3800 * @brief Apply a function to every element of a sequence.
3801 * @ingroup non_mutating_algorithms
3802 * @param __first An input iterator.
3803 * @param __last An input iterator.
3804 * @param __f A unary function object.
3805 * @return @p __f
3806 *
3807 * Applies the function object @p __f to each element in the range
3808 * @p [first,last). @p __f must not modify the order of the sequence.
3809 * If @p __f has a return value it is ignored.
3810 */
3811 template<typename _InputIterator, typename _Function>
3812 _GLIBCXX20_CONSTEXPR
3813 _Function
3814 for_each(_InputIterator __first, _InputIterator __last, _Function __f)
3815 {
3816 // concept requirements
3817 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3818 __glibcxx_requires_valid_range(__first, __last);
3819 for (; __first != __last; ++__first)
3820 __f(*__first);
3821 return __f; // N.B. [alg.foreach] says std::move(f) but it's redundant.
3822 }
3823
3824#if __cplusplus >= 201703L
3825 /**
3826 * @brief Apply a function to every element of a sequence.
3827 * @ingroup non_mutating_algorithms
3828 * @param __first An input iterator.
3829 * @param __n A value convertible to an integer.
3830 * @param __f A unary function object.
3831 * @return `__first+__n`
3832 *
3833 * Applies the function object `__f` to each element in the range
3834 * `[first, first+n)`. `__f` must not modify the order of the sequence.
3835 * If `__f` has a return value it is ignored.
3836 */
3837 template<typename _InputIterator, typename _Size, typename _Function>
3838 _GLIBCXX20_CONSTEXPR
3839 _InputIterator
3840 for_each_n(_InputIterator __first, _Size __n, _Function __f)
3841 {
3842 auto __n2 = std::__size_to_integer(__n);
3843 using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
3844 if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
3845 {
3846 if (__n2 <= 0)
3847 return __first;
3848 auto __last = __first + __n2;
3849 std::for_each(__first, __last, std::move(__f));
3850 return __last;
3851 }
3852 else
3853 {
3854 while (__n2-->0)
3855 {
3856 __f(*__first);
3857 ++__first;
3858 }
3859 return __first;
3860 }
3861 }
3862#endif // C++17
3863
3864 /**
3865 * @brief Find the first occurrence of a value in a sequence.
3866 * @ingroup non_mutating_algorithms
3867 * @param __first An input iterator.
3868 * @param __last An input iterator.
3869 * @param __val The value to find.
3870 * @return The first iterator @c i in the range @p [__first,__last)
3871 * such that @c *i == @p __val, or @p __last if no such iterator exists.
3872 */
3873 template<typename _InputIterator, typename _Tp>
3874 _GLIBCXX20_CONSTEXPR
3875 inline _InputIterator
3876 find(_InputIterator __first, _InputIterator __last,
3877 const _Tp& __val)
3878 {
3879 // concept requirements
3880 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3881 __glibcxx_function_requires(_EqualOpConcept<
3882 typename iterator_traits<_InputIterator>::value_type, _Tp>)
3883 __glibcxx_requires_valid_range(__first, __last);
3884 return std::__find_if(__first, __last,
3885 __gnu_cxx::__ops::__iter_equals_val(__val));
3886 }
3887
3888 /**
3889 * @brief Find the first element in a sequence for which a
3890 * predicate is true.
3891 * @ingroup non_mutating_algorithms
3892 * @param __first An input iterator.
3893 * @param __last An input iterator.
3894 * @param __pred A predicate.
3895 * @return The first iterator @c i in the range @p [__first,__last)
3896 * such that @p __pred(*i) is true, or @p __last if no such iterator exists.
3897 */
3898 template<typename _InputIterator, typename _Predicate>
3899 _GLIBCXX20_CONSTEXPR
3900 inline _InputIterator
3901 find_if(_InputIterator __first, _InputIterator __last,
3902 _Predicate __pred)
3903 {
3904 // concept requirements
3905 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3906 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
3907 typename iterator_traits<_InputIterator>::value_type>)
3908 __glibcxx_requires_valid_range(__first, __last);
3909
3910 return std::__find_if(__first, __last,
3911 __gnu_cxx::__ops::__pred_iter(__pred));
3912 }
3913
3914 /**
3915 * @brief Find element from a set in a sequence.
3916 * @ingroup non_mutating_algorithms
3917 * @param __first1 Start of range to search.
3918 * @param __last1 End of range to search.
3919 * @param __first2 Start of match candidates.
3920 * @param __last2 End of match candidates.
3921 * @return The first iterator @c i in the range
3922 * @p [__first1,__last1) such that @c *i == @p *(i2) such that i2 is an
3923 * iterator in [__first2,__last2), or @p __last1 if no such iterator exists.
3924 *
3925 * Searches the range @p [__first1,__last1) for an element that is
3926 * equal to some element in the range [__first2,__last2). If
3927 * found, returns an iterator in the range [__first1,__last1),
3928 * otherwise returns @p __last1.
3929 */
3930 template<typename _InputIterator, typename _ForwardIterator>
3931 _GLIBCXX20_CONSTEXPR
3932 _InputIterator
3933 find_first_of(_InputIterator __first1, _InputIterator __last1,
3934 _ForwardIterator __first2, _ForwardIterator __last2)
3935 {
3936 // concept requirements
3937 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3938 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3939 __glibcxx_function_requires(_EqualOpConcept<
3940 typename iterator_traits<_InputIterator>::value_type,
3941 typename iterator_traits<_ForwardIterator>::value_type>)
3942 __glibcxx_requires_valid_range(__first1, __last1);
3943 __glibcxx_requires_valid_range(__first2, __last2);
3944
3945 for (; __first1 != __last1; ++__first1)
3946 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
3947 if (*__first1 == *__iter)
3948 return __first1;
3949 return __last1;
3950 }
3951
3952 /**
3953 * @brief Find element from a set in a sequence using a predicate.
3954 * @ingroup non_mutating_algorithms
3955 * @param __first1 Start of range to search.
3956 * @param __last1 End of range to search.
3957 * @param __first2 Start of match candidates.
3958 * @param __last2 End of match candidates.
3959 * @param __comp Predicate to use.
3960 * @return The first iterator @c i in the range
3961 * @p [__first1,__last1) such that @c comp(*i, @p *(i2)) is true
3962 * and i2 is an iterator in [__first2,__last2), or @p __last1 if no
3963 * such iterator exists.
3964 *
3965
3966 * Searches the range @p [__first1,__last1) for an element that is
3967 * equal to some element in the range [__first2,__last2). If
3968 * found, returns an iterator in the range [__first1,__last1),
3969 * otherwise returns @p __last1.
3970 */
3971 template<typename _InputIterator, typename _ForwardIterator,
3972 typename _BinaryPredicate>
3973 _GLIBCXX20_CONSTEXPR
3974 _InputIterator
3975 find_first_of(_InputIterator __first1, _InputIterator __last1,
3976 _ForwardIterator __first2, _ForwardIterator __last2,
3977 _BinaryPredicate __comp)
3978 {
3979 // concept requirements
3980 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
3981 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3982 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
3983 typename iterator_traits<_InputIterator>::value_type,
3984 typename iterator_traits<_ForwardIterator>::value_type>)
3985 __glibcxx_requires_valid_range(__first1, __last1);
3986 __glibcxx_requires_valid_range(__first2, __last2);
3987
3988 for (; __first1 != __last1; ++__first1)
3989 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
3990 if (__comp(*__first1, *__iter))
3991 return __first1;
3992 return __last1;
3993 }
3994
3995 /**
3996 * @brief Find two adjacent values in a sequence that are equal.
3997 * @ingroup non_mutating_algorithms
3998 * @param __first A forward iterator.
3999 * @param __last A forward iterator.
4000 * @return The first iterator @c i such that @c i and @c i+1 are both
4001 * valid iterators in @p [__first,__last) and such that @c *i == @c *(i+1),
4002 * or @p __last if no such iterator exists.
4003 */
4004 template<typename _ForwardIterator>
4005 _GLIBCXX20_CONSTEXPR
4006 inline _ForwardIterator
4007 adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
4008 {
4009 // concept requirements
4010 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
4011 __glibcxx_function_requires(_EqualityComparableConcept<
4012 typename iterator_traits<_ForwardIterator>::value_type>)
4013 __glibcxx_requires_valid_range(__first, __last);
4014
4015 return std::__adjacent_find(__first, __last,
4016 __gnu_cxx::__ops::__iter_equal_to_iter());
4017 }
4018
4019 /**
4020 * @brief Find two adjacent values in a sequence using a predicate.
4021 * @ingroup non_mutating_algorithms
4022 * @param __first A forward iterator.
4023 * @param __last A forward iterator.
4024 * @param __binary_pred A binary predicate.
4025 * @return The first iterator @c i such that @c i and @c i+1 are both
4026 * valid iterators in @p [__first,__last) and such that
4027 * @p __binary_pred(*i,*(i+1)) is true, or @p __last if no such iterator
4028 * exists.
4029 */
4030 template<typename _ForwardIterator, typename _BinaryPredicate>
4031 _GLIBCXX20_CONSTEXPR
4032 inline _ForwardIterator
4033 adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
4034 _BinaryPredicate __binary_pred)
4035 {
4036 // concept requirements
4037 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
4038 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
4039 typename iterator_traits<_ForwardIterator>::value_type,
4040 typename iterator_traits<_ForwardIterator>::value_type>)
4041 __glibcxx_requires_valid_range(__first, __last);
4042
4043 return std::__adjacent_find(__first, __last,
4044 __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
4045 }
4046
4047 /**
4048 * @brief Count the number of copies of a value in a sequence.
4049 * @ingroup non_mutating_algorithms
4050 * @param __first An input iterator.
4051 * @param __last An input iterator.
4052 * @param __value The value to be counted.
4053 * @return The number of iterators @c i in the range @p [__first,__last)
4054 * for which @c *i == @p __value
4055 */
4056 template<typename _InputIterator, typename _Tp>
4057 _GLIBCXX20_CONSTEXPR
4058 inline typename iterator_traits<_InputIterator>::difference_type
4059 count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
4060 {
4061 // concept requirements
4062 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
4063 __glibcxx_function_requires(_EqualOpConcept<
4064 typename iterator_traits<_InputIterator>::value_type, _Tp>)
4065 __glibcxx_requires_valid_range(__first, __last);
4066
4067 return std::__count_if(__first, __last,
4068 __gnu_cxx::__ops::__iter_equals_val(__value));
4069 }
4070
4071 /**
4072 * @brief Count the elements of a sequence for which a predicate is true.
4073 * @ingroup non_mutating_algorithms
4074 * @param __first An input iterator.
4075 * @param __last An input iterator.
4076 * @param __pred A predicate.
4077 * @return The number of iterators @c i in the range @p [__first,__last)
4078 * for which @p __pred(*i) is true.
4079 */
4080 template<typename _InputIterator, typename _Predicate>
4081 _GLIBCXX20_CONSTEXPR
4082 inline typename iterator_traits<_InputIterator>::difference_type
4083 count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
4084 {
4085 // concept requirements
4086 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
4087 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
4088 typename iterator_traits<_InputIterator>::value_type>)
4089 __glibcxx_requires_valid_range(__first, __last);
4090
4091 return std::__count_if(__first, __last,
4092 __gnu_cxx::__ops::__pred_iter(__pred));
4093 }
4094
4095 /**
4096 * @brief Search a sequence for a matching sub-sequence.
4097 * @ingroup non_mutating_algorithms
4098 * @param __first1 A forward iterator.
4099 * @param __last1 A forward iterator.
4100 * @param __first2 A forward iterator.
4101 * @param __last2 A forward iterator.
4102 * @return The first iterator @c i in the range @p
4103 * [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == @p
4104 * *(__first2+N) for each @c N in the range @p
4105 * [0,__last2-__first2), or @p __last1 if no such iterator exists.
4106 *
4107 * Searches the range @p [__first1,__last1) for a sub-sequence that
4108 * compares equal value-by-value with the sequence given by @p
4109 * [__first2,__last2) and returns an iterator to the first element
4110 * of the sub-sequence, or @p __last1 if the sub-sequence is not
4111 * found.
4112 *
4113 * Because the sub-sequence must lie completely within the range @p
4114 * [__first1,__last1) it must start at a position less than @p
4115 * __last1-(__last2-__first2) where @p __last2-__first2 is the
4116 * length of the sub-sequence.
4117 *
4118 * This means that the returned iterator @c i will be in the range
4119 * @p [__first1,__last1-(__last2-__first2))
4120 */
4121 template<typename _ForwardIterator1, typename _ForwardIterator2>
4122 _GLIBCXX20_CONSTEXPR
4123 inline _ForwardIterator1
4124 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
4125 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
4126 {
4127 // concept requirements
4128 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
4129 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
4130 __glibcxx_function_requires(_EqualOpConcept<
4131 typename iterator_traits<_ForwardIterator1>::value_type,
4132 typename iterator_traits<_ForwardIterator2>::value_type>)
4133 __glibcxx_requires_valid_range(__first1, __last1);
4134 __glibcxx_requires_valid_range(__first2, __last2);
4135
4136 return std::__search(__first1, __last1, __first2, __last2,
4137 __gnu_cxx::__ops::__iter_equal_to_iter());
4138 }
4139
4140 /**
4141 * @brief Search a sequence for a matching sub-sequence using a predicate.
4142 * @ingroup non_mutating_algorithms
4143 * @param __first1 A forward iterator.
4144 * @param __last1 A forward iterator.
4145 * @param __first2 A forward iterator.
4146 * @param __last2 A forward iterator.
4147 * @param __predicate A binary predicate.
4148 * @return The first iterator @c i in the range
4149 * @p [__first1,__last1-(__last2-__first2)) such that
4150 * @p __predicate(*(i+N),*(__first2+N)) is true for each @c N in the range
4151 * @p [0,__last2-__first2), or @p __last1 if no such iterator exists.
4152 *
4153 * Searches the range @p [__first1,__last1) for a sub-sequence that
4154 * compares equal value-by-value with the sequence given by @p
4155 * [__first2,__last2), using @p __predicate to determine equality,
4156 * and returns an iterator to the first element of the
4157 * sub-sequence, or @p __last1 if no such iterator exists.
4158 *
4159 * @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
4160 */
4161 template<typename _ForwardIterator1, typename _ForwardIterator2,
4162 typename _BinaryPredicate>
4163 _GLIBCXX20_CONSTEXPR
4164 inline _ForwardIterator1
4165 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
4166 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
4167 _BinaryPredicate __predicate)
4168 {
4169 // concept requirements
4170 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
4171 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
4172 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
4173 typename iterator_traits<_ForwardIterator1>::value_type,
4174 typename iterator_traits<_ForwardIterator2>::value_type>)
4175 __glibcxx_requires_valid_range(__first1, __last1);
4176 __glibcxx_requires_valid_range(__first2, __last2);
4177
4178 return std::__search(__first1, __last1, __first2, __last2,
4179 __gnu_cxx::__ops::__iter_comp_iter(__predicate));
4180 }
4181
4182 /**
4183 * @brief Search a sequence for a number of consecutive values.
4184 * @ingroup non_mutating_algorithms
4185 * @param __first A forward iterator.
4186 * @param __last A forward iterator.
4187 * @param __count The number of consecutive values.
4188 * @param __val The value to find.
4189 * @return The first iterator @c i in the range @p
4190 * [__first,__last-__count) such that @c *(i+N) == @p __val for
4191 * each @c N in the range @p [0,__count), or @p __last if no such
4192 * iterator exists.
4193 *
4194 * Searches the range @p [__first,__last) for @p count consecutive elements
4195 * equal to @p __val.
4196 */
4197 template<typename _ForwardIterator, typename _Integer, typename _Tp>
4198 _GLIBCXX20_CONSTEXPR
4199 inline _ForwardIterator
4200 search_n(_ForwardIterator __first, _ForwardIterator __last,
4201 _Integer __count, const _Tp& __val)
4202 {
4203 // concept requirements
4204 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
4205 __glibcxx_function_requires(_EqualOpConcept<
4206 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
4207 __glibcxx_requires_valid_range(__first, __last);
4208
4209 return std::__search_n(__first, __last, __count,
4210 __gnu_cxx::__ops::__iter_equals_val(__val));
4211 }
4212
4213
4214 /**
4215 * @brief Search a sequence for a number of consecutive values using a
4216 * predicate.
4217 * @ingroup non_mutating_algorithms
4218 * @param __first A forward iterator.
4219 * @param __last A forward iterator.
4220 * @param __count The number of consecutive values.
4221 * @param __val The value to find.
4222 * @param __binary_pred A binary predicate.
4223 * @return The first iterator @c i in the range @p
4224 * [__first,__last-__count) such that @p
4225 * __binary_pred(*(i+N),__val) is true for each @c N in the range
4226 * @p [0,__count), or @p __last if no such iterator exists.
4227 *
4228 * Searches the range @p [__first,__last) for @p __count
4229 * consecutive elements for which the predicate returns true.
4230 */
4231 template<typename _ForwardIterator, typename _Integer, typename _Tp,
4232 typename _BinaryPredicate>
4233 _GLIBCXX20_CONSTEXPR
4234 inline _ForwardIterator
4235 search_n(_ForwardIterator __first, _ForwardIterator __last,
4236 _Integer __count, const _Tp& __val,
4237 _BinaryPredicate __binary_pred)
4238 {
4239 // concept requirements
4240 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
4241 __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
4242 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
4243 __glibcxx_requires_valid_range(__first, __last);
4244
4245 return std::__search_n(__first, __last, __count,
4246 __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
4247 }
4248
4249#if __cplusplus >= 201703L
4250 /** @brief Search a sequence using a Searcher object.
4251 *
4252 * @param __first A forward iterator.
4253 * @param __last A forward iterator.
4254 * @param __searcher A callable object.
4255 * @return @p __searcher(__first,__last).first
4256 */
4257 template<typename _ForwardIterator, typename _Searcher>
4258 _GLIBCXX20_CONSTEXPR
4259 inline _ForwardIterator
4260 search(_ForwardIterator __first, _ForwardIterator __last,
4261 const _Searcher& __searcher)
4262 { return __searcher(__first, __last).first; }
4263#endif
4264
4265 /**
4266 * @brief Perform an operation on a sequence.
4267 * @ingroup mutating_algorithms
4268 * @param __first An input iterator.
4269 * @param __last An input iterator.
4270 * @param __result An output iterator.
4271 * @param __unary_op A unary operator.
4272 * @return An output iterator equal to @p __result+(__last-__first).
4273 *
4274 * Applies the operator to each element in the input range and assigns
4275 * the results to successive elements of the output sequence.
4276 * Evaluates @p *(__result+N)=unary_op(*(__first+N)) for each @c N in the
4277 * range @p [0,__last-__first).
4278 *
4279 * @p unary_op must not alter its argument.
4280 */
4281 template<typename _InputIterator, typename _OutputIterator,
4282 typename _UnaryOperation>
4283 _GLIBCXX20_CONSTEXPR
4284 _OutputIterator
4285 transform(_InputIterator __first, _InputIterator __last,
4286 _OutputIterator __result, _UnaryOperation __unary_op)
4287 {
4288 // concept requirements
4289 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
4290 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4291 // "the type returned by a _UnaryOperation"
4292 __typeof__(__unary_op(*__first))>)
4293 __glibcxx_requires_valid_range(__first, __last);
4294
4295 for (; __first != __last; ++__first, (void)++__result)
4296 *__result = __unary_op(*__first);
4297 return __result;
4298 }
4299
4300 /**
4301 * @brief Perform an operation on corresponding elements of two sequences.
4302 * @ingroup mutating_algorithms
4303 * @param __first1 An input iterator.
4304 * @param __last1 An input iterator.
4305 * @param __first2 An input iterator.
4306 * @param __result An output iterator.
4307 * @param __binary_op A binary operator.
4308 * @return An output iterator equal to @p result+(last-first).
4309 *
4310 * Applies the operator to the corresponding elements in the two
4311 * input ranges and assigns the results to successive elements of the
4312 * output sequence.
4313 * Evaluates @p
4314 * *(__result+N)=__binary_op(*(__first1+N),*(__first2+N)) for each
4315 * @c N in the range @p [0,__last1-__first1).
4316 *
4317 * @p binary_op must not alter either of its arguments.
4318 */
4319 template<typename _InputIterator1, typename _InputIterator2,
4320 typename _OutputIterator, typename _BinaryOperation>
4321 _GLIBCXX20_CONSTEXPR
4322 _OutputIterator
4323 transform(_InputIterator1 __first1, _InputIterator1 __last1,
4324 _InputIterator2 __first2, _OutputIterator __result,
4325 _BinaryOperation __binary_op)
4326 {
4327 // concept requirements
4328 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
4329 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
4330 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4331 // "the type returned by a _BinaryOperation"
4332 __typeof__(__binary_op(*__first1,*__first2))>)
4333 __glibcxx_requires_valid_range(__first1, __last1);
4334
4335 for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
4336 *__result = __binary_op(*__first1, *__first2);
4337 return __result;
4338 }
4339
4340 /**
4341 * @brief Replace each occurrence of one value in a sequence with another
4342 * value.
4343 * @ingroup mutating_algorithms
4344 * @param __first A forward iterator.
4345 * @param __last A forward iterator.
4346 * @param __old_value The value to be replaced.
4347 * @param __new_value The replacement value.
4348 * @return replace() returns no value.
4349 *
4350 * For each iterator @c i in the range @p [__first,__last) if @c *i ==
4351 * @p __old_value then the assignment @c *i = @p __new_value is performed.
4352 */
4353 template<typename _ForwardIterator, typename _Tp>
4354 _GLIBCXX20_CONSTEXPR
4355 void
4356 replace(_ForwardIterator __first, _ForwardIterator __last,
4357 const _Tp& __old_value, const _Tp& __new_value)
4358 {
4359 // concept requirements
4360 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
4361 _ForwardIterator>)
4362 __glibcxx_function_requires(_EqualOpConcept<
4363 typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
4364 __glibcxx_function_requires(_ConvertibleConcept<_Tp,
4365 typename iterator_traits<_ForwardIterator>::value_type>)
4366 __glibcxx_requires_valid_range(__first, __last);
4367
4368 for (; __first != __last; ++__first)
4369 if (*__first == __old_value)
4370 *__first = __new_value;
4371 }
4372
4373 /**
4374 * @brief Replace each value in a sequence for which a predicate returns
4375 * true with another value.
4376 * @ingroup mutating_algorithms
4377 * @param __first A forward iterator.
4378 * @param __last A forward iterator.
4379 * @param __pred A predicate.
4380 * @param __new_value The replacement value.
4381 * @return replace_if() returns no value.
4382 *
4383 * For each iterator @c i in the range @p [__first,__last) if @p __pred(*i)
4384 * is true then the assignment @c *i = @p __new_value is performed.
4385 */
4386 template<typename _ForwardIterator, typename _Predicate, typename _Tp>
4387 _GLIBCXX20_CONSTEXPR
4388 void
4389 replace_if(_ForwardIterator __first, _ForwardIterator __last,
4390 _Predicate __pred, const _Tp& __new_value)
4391 {
4392 // concept requirements
4393 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
4394 _ForwardIterator>)
4395 __glibcxx_function_requires(_ConvertibleConcept<_Tp,
4396 typename iterator_traits<_ForwardIterator>::value_type>)
4397 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
4398 typename iterator_traits<_ForwardIterator>::value_type>)
4399 __glibcxx_requires_valid_range(__first, __last);
4400
4401 for (; __first != __last; ++__first)
4402 if (__pred(*__first))
4403 *__first = __new_value;
4404 }
4405
4406 /**
4407 * @brief Assign the result of a function object to each value in a
4408 * sequence.
4409 * @ingroup mutating_algorithms
4410 * @param __first A forward iterator.
4411 * @param __last A forward iterator.
4412 * @param __gen A function object taking no arguments and returning
4413 * std::iterator_traits<_ForwardIterator>::value_type
4414 * @return generate() returns no value.
4415 *
4416 * Performs the assignment @c *i = @p __gen() for each @c i in the range
4417 * @p [__first,__last).
4418 */
4419 template<typename _ForwardIterator, typename _Generator>
4420 _GLIBCXX20_CONSTEXPR
4421 void
4422 generate(_ForwardIterator __first, _ForwardIterator __last,
4423 _Generator __gen)
4424 {
4425 // concept requirements
4426 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
4427 __glibcxx_function_requires(_GeneratorConcept<_Generator,
4428 typename iterator_traits<_ForwardIterator>::value_type>)
4429 __glibcxx_requires_valid_range(__first, __last);
4430
4431 for (; __first != __last; ++__first)
4432 *__first = __gen();
4433 }
4434
4435 /**
4436 * @brief Assign the result of a function object to each value in a
4437 * sequence.
4438 * @ingroup mutating_algorithms
4439 * @param __first A forward iterator.
4440 * @param __n The length of the sequence.
4441 * @param __gen A function object taking no arguments and returning
4442 * std::iterator_traits<_ForwardIterator>::value_type
4443 * @return The end of the sequence, @p __first+__n
4444 *
4445 * Performs the assignment @c *i = @p __gen() for each @c i in the range
4446 * @p [__first,__first+__n).
4447 *
4448 * If @p __n is negative, the function does nothing and returns @p __first.
4449 */
4450 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4451 // DR 865. More algorithms that throw away information
4452 // DR 426. search_n(), fill_n(), and generate_n() with negative n
4453 template<typename _OutputIterator, typename _Size, typename _Generator>
4454 _GLIBCXX20_CONSTEXPR
4455 _OutputIterator
4456 generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
4457 {
4458 // concept requirements
4459 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4460 // "the type returned by a _Generator"
4461 __typeof__(__gen())>)
4462
4463 typedef __decltype(std::__size_to_integer(__n)) _IntSize;
4464 for (_IntSize __niter = std::__size_to_integer(__n);
4465 __niter > 0; --__niter, (void) ++__first)
4466 *__first = __gen();
4467 return __first;
4468 }
4469
4470 /**
4471 * @brief Copy a sequence, removing consecutive duplicate values.
4472 * @ingroup mutating_algorithms
4473 * @param __first An input iterator.
4474 * @param __last An input iterator.
4475 * @param __result An output iterator.
4476 * @return An iterator designating the end of the resulting sequence.
4477 *
4478 * Copies each element in the range @p [__first,__last) to the range
4479 * beginning at @p __result, except that only the first element is copied
4480 * from groups of consecutive elements that compare equal.
4481 * unique_copy() is stable, so the relative order of elements that are
4482 * copied is unchanged.
4483 *
4484 * _GLIBCXX_RESOLVE_LIB_DEFECTS
4485 * DR 241. Does unique_copy() require CopyConstructible and Assignable?
4486 *
4487 * _GLIBCXX_RESOLVE_LIB_DEFECTS
4488 * DR 538. 241 again: Does unique_copy() require CopyConstructible and
4489 * Assignable?
4490 */
4491 template<typename _InputIterator, typename _OutputIterator>
4492 _GLIBCXX20_CONSTEXPR
4493 inline _OutputIterator
4494 unique_copy(_InputIterator __first, _InputIterator __last,
4495 _OutputIterator __result)
4496 {
4497 // concept requirements
4498 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
4499 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4500 typename iterator_traits<_InputIterator>::value_type>)
4501 __glibcxx_function_requires(_EqualityComparableConcept<
4502 typename iterator_traits<_InputIterator>::value_type>)
4503 __glibcxx_requires_valid_range(__first, __last);
4504
4505 if (__first == __last)
4506 return __result;
4507 return std::__unique_copy(__first, __last, __result,
4508 __gnu_cxx::__ops::__iter_equal_to_iter(),
4509 std::__iterator_category(__first),
4510 std::__iterator_category(__result));
4511 }
4512
4513 /**
4514 * @brief Copy a sequence, removing consecutive values using a predicate.
4515 * @ingroup mutating_algorithms
4516 * @param __first An input iterator.
4517 * @param __last An input iterator.
4518 * @param __result An output iterator.
4519 * @param __binary_pred A binary predicate.
4520 * @return An iterator designating the end of the resulting sequence.
4521 *
4522 * Copies each element in the range @p [__first,__last) to the range
4523 * beginning at @p __result, except that only the first element is copied
4524 * from groups of consecutive elements for which @p __binary_pred returns
4525 * true.
4526 * unique_copy() is stable, so the relative order of elements that are
4527 * copied is unchanged.
4528 *
4529 * _GLIBCXX_RESOLVE_LIB_DEFECTS
4530 * DR 241. Does unique_copy() require CopyConstructible and Assignable?
4531 */
4532 template<typename _InputIterator, typename _OutputIterator,
4533 typename _BinaryPredicate>
4534 _GLIBCXX20_CONSTEXPR
4535 inline _OutputIterator
4536 unique_copy(_InputIterator __first, _InputIterator __last,
4537 _OutputIterator __result,
4538 _BinaryPredicate __binary_pred)
4539 {
4540 // concept requirements -- predicates checked later
4541 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
4542 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4543 typename iterator_traits<_InputIterator>::value_type>)
4544 __glibcxx_requires_valid_range(__first, __last);
4545
4546 if (__first == __last)
4547 return __result;
4548 return std::__unique_copy(__first, __last, __result,
4549 __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
4550 std::__iterator_category(__first),
4551 std::__iterator_category(__result));
4552 }
4553
4554#if _GLIBCXX_HOSTED
4555 /**
4556 * @brief Randomly shuffle the elements of a sequence.
4557 * @ingroup mutating_algorithms
4558 * @param __first A forward iterator.
4559 * @param __last A forward iterator.
4560 * @return Nothing.
4561 *
4562 * Reorder the elements in the range @p [__first,__last) using a random
4563 * distribution, so that every possible ordering of the sequence is
4564 * equally likely.
4565 */
4566 template<typename _RandomAccessIterator>
4567 inline void
4568 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
4569 {
4570 // concept requirements
4571 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4572 _RandomAccessIterator>)
4573 __glibcxx_requires_valid_range(__first, __last);
4574
4575 if (__first != __last)
4576 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
4577 {
4578 // XXX rand() % N is not uniformly distributed
4579 _RandomAccessIterator __j = __first
4580 + std::rand() % ((__i - __first) + 1);
4581 if (__i != __j)
4582 std::iter_swap(__i, __j);
4583 }
4584 }
4585#endif
4586
4587 /**
4588 * @brief Shuffle the elements of a sequence using a random number
4589 * generator.
4590 * @ingroup mutating_algorithms
4591 * @param __first A forward iterator.
4592 * @param __last A forward iterator.
4593 * @param __rand The RNG functor or function.
4594 * @return Nothing.
4595 *
4596 * Reorders the elements in the range @p [__first,__last) using @p __rand to
4597 * provide a random distribution. Calling @p __rand(N) for a positive
4598 * integer @p N should return a randomly chosen integer from the
4599 * range [0,N).
4600 */
4601 template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
4602 void
4603 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
4604#if __cplusplus >= 201103L
4605 _RandomNumberGenerator&& __rand)
4606#else
4607 _RandomNumberGenerator& __rand)
4608#endif
4609 {
4610 // concept requirements
4611 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4612 _RandomAccessIterator>)
4613 __glibcxx_requires_valid_range(__first, __last);
4614
4615 if (__first == __last)
4616 return;
4617 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
4618 {
4619 _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
4620 if (__i != __j)
4621 std::iter_swap(__i, __j);
4622 }
4623 }
4624
4625
4626 /**
4627 * @brief Move elements for which a predicate is true to the beginning
4628 * of a sequence.
4629 * @ingroup mutating_algorithms
4630 * @param __first A forward iterator.
4631 * @param __last A forward iterator.
4632 * @param __pred A predicate functor.
4633 * @return An iterator @p middle such that @p __pred(i) is true for each
4634 * iterator @p i in the range @p [__first,middle) and false for each @p i
4635 * in the range @p [middle,__last).
4636 *
4637 * @p __pred must not modify its operand. @p partition() does not preserve
4638 * the relative ordering of elements in each group, use
4639 * @p stable_partition() if this is needed.
4640 */
4641 template<typename _ForwardIterator, typename _Predicate>
4642 _GLIBCXX20_CONSTEXPR
4643 inline _ForwardIterator
4644 partition(_ForwardIterator __first, _ForwardIterator __last,
4645 _Predicate __pred)
4646 {
4647 // concept requirements
4648 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
4649 _ForwardIterator>)
4650 __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
4651 typename iterator_traits<_ForwardIterator>::value_type>)
4652 __glibcxx_requires_valid_range(__first, __last);
4653
4654 return std::__partition(__first, __last, __pred,
4655 std::__iterator_category(__first));
4656 }
4657
4658
4659 /**
4660 * @brief Sort the smallest elements of a sequence.
4661 * @ingroup sorting_algorithms
4662 * @param __first An iterator.
4663 * @param __middle Another iterator.
4664 * @param __last Another iterator.
4665 * @return Nothing.
4666 *
4667 * Sorts the smallest @p (__middle-__first) elements in the range
4668 * @p [first,last) and moves them to the range @p [__first,__middle). The
4669 * order of the remaining elements in the range @p [__middle,__last) is
4670 * undefined.
4671 * After the sort if @e i and @e j are iterators in the range
4672 * @p [__first,__middle) such that i precedes j and @e k is an iterator in
4673 * the range @p [__middle,__last) then *j<*i and *k<*i are both false.
4674 */
4675 template<typename _RandomAccessIterator>
4676 _GLIBCXX20_CONSTEXPR
4677 inline void
4678 partial_sort(_RandomAccessIterator __first,
4679 _RandomAccessIterator __middle,
4680 _RandomAccessIterator __last)
4681 {
4682 // concept requirements
4683 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4684 _RandomAccessIterator>)
4685 __glibcxx_function_requires(_LessThanComparableConcept<
4686 typename iterator_traits<_RandomAccessIterator>::value_type>)
4687 __glibcxx_requires_valid_range(__first, __middle);
4688 __glibcxx_requires_valid_range(__middle, __last);
4689 __glibcxx_requires_irreflexive(__first, __last);
4690
4691 std::__partial_sort(__first, __middle, __last,
4692 __gnu_cxx::__ops::__iter_less_iter());
4693 }
4694
4695 /**
4696 * @brief Sort the smallest elements of a sequence using a predicate
4697 * for comparison.
4698 * @ingroup sorting_algorithms
4699 * @param __first An iterator.
4700 * @param __middle Another iterator.
4701 * @param __last Another iterator.
4702 * @param __comp A comparison functor.
4703 * @return Nothing.
4704 *
4705 * Sorts the smallest @p (__middle-__first) elements in the range
4706 * @p [__first,__last) and moves them to the range @p [__first,__middle). The
4707 * order of the remaining elements in the range @p [__middle,__last) is
4708 * undefined.
4709 * After the sort if @e i and @e j are iterators in the range
4710 * @p [__first,__middle) such that i precedes j and @e k is an iterator in
4711 * the range @p [__middle,__last) then @p *__comp(j,*i) and @p __comp(*k,*i)
4712 * are both false.
4713 */
4714 template<typename _RandomAccessIterator, typename _Compare>
4715 _GLIBCXX20_CONSTEXPR
4716 inline void
4717 partial_sort(_RandomAccessIterator __first,
4718 _RandomAccessIterator __middle,
4719 _RandomAccessIterator __last,
4720 _Compare __comp)
4721 {
4722 // concept requirements
4723 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4724 _RandomAccessIterator>)
4725 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
4726 typename iterator_traits<_RandomAccessIterator>::value_type,
4727 typename iterator_traits<_RandomAccessIterator>::value_type>)
4728 __glibcxx_requires_valid_range(__first, __middle);
4729 __glibcxx_requires_valid_range(__middle, __last);
4730 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
4731
4732 std::__partial_sort(__first, __middle, __last,
4733 __gnu_cxx::__ops::__iter_comp_iter(__comp));
4734 }
4735
4736 /**
4737 * @brief Sort a sequence just enough to find a particular position.
4738 * @ingroup sorting_algorithms
4739 * @param __first An iterator.
4740 * @param __nth Another iterator.
4741 * @param __last Another iterator.
4742 * @return Nothing.
4743 *
4744 * Rearranges the elements in the range @p [__first,__last) so that @p *__nth
4745 * is the same element that would have been in that position had the
4746 * whole sequence been sorted. The elements either side of @p *__nth are
4747 * not completely sorted, but for any iterator @e i in the range
4748 * @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
4749 * holds that *j < *i is false.
4750 */
4751 template<typename _RandomAccessIterator>
4752 _GLIBCXX20_CONSTEXPR
4753 inline void
4754 nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
4755 _RandomAccessIterator __last)
4756 {
4757 // concept requirements
4758 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4759 _RandomAccessIterator>)
4760 __glibcxx_function_requires(_LessThanComparableConcept<
4761 typename iterator_traits<_RandomAccessIterator>::value_type>)
4762 __glibcxx_requires_valid_range(__first, __nth);
4763 __glibcxx_requires_valid_range(__nth, __last);
4764 __glibcxx_requires_irreflexive(__first, __last);
4765
4766 if (__first == __last || __nth == __last)
4767 return;
4768
4769 std::__introselect(__first, __nth, __last,
4770 std::__lg(__last - __first) * 2,
4771 __gnu_cxx::__ops::__iter_less_iter());
4772 }
4773
4774 /**
4775 * @brief Sort a sequence just enough to find a particular position
4776 * using a predicate for comparison.
4777 * @ingroup sorting_algorithms
4778 * @param __first An iterator.
4779 * @param __nth Another iterator.
4780 * @param __last Another iterator.
4781 * @param __comp A comparison functor.
4782 * @return Nothing.
4783 *
4784 * Rearranges the elements in the range @p [__first,__last) so that @p *__nth
4785 * is the same element that would have been in that position had the
4786 * whole sequence been sorted. The elements either side of @p *__nth are
4787 * not completely sorted, but for any iterator @e i in the range
4788 * @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
4789 * holds that @p __comp(*j,*i) is false.
4790 */
4791 template<typename _RandomAccessIterator, typename _Compare>
4792 _GLIBCXX20_CONSTEXPR
4793 inline void
4794 nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
4795 _RandomAccessIterator __last, _Compare __comp)
4796 {
4797 // concept requirements
4798 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4799 _RandomAccessIterator>)
4800 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
4801 typename iterator_traits<_RandomAccessIterator>::value_type,
4802 typename iterator_traits<_RandomAccessIterator>::value_type>)
4803 __glibcxx_requires_valid_range(__first, __nth);
4804 __glibcxx_requires_valid_range(__nth, __last);
4805 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
4806
4807 if (__first == __last || __nth == __last)
4808 return;
4809
4810 std::__introselect(__first, __nth, __last,
4811 std::__lg(__last - __first) * 2,
4812 __gnu_cxx::__ops::__iter_comp_iter(__comp));
4813 }
4814
4815 /**
4816 * @brief Sort the elements of a sequence.
4817 * @ingroup sorting_algorithms
4818 * @param __first An iterator.
4819 * @param __last Another iterator.
4820 * @return Nothing.
4821 *
4822 * Sorts the elements in the range @p [__first,__last) in ascending order,
4823 * such that for each iterator @e i in the range @p [__first,__last-1),
4824 * *(i+1)<*i is false.
4825 *
4826 * The relative ordering of equivalent elements is not preserved, use
4827 * @p stable_sort() if this is needed.
4828 */
4829 template<typename _RandomAccessIterator>
4830 _GLIBCXX20_CONSTEXPR
4831 inline void
4832 sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
4833 {
4834 // concept requirements
4835 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4836 _RandomAccessIterator>)
4837 __glibcxx_function_requires(_LessThanComparableConcept<
4838 typename iterator_traits<_RandomAccessIterator>::value_type>)
4839 __glibcxx_requires_valid_range(__first, __last);
4840 __glibcxx_requires_irreflexive(__first, __last);
4841
4842 std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
4843 }
4844
4845 /**
4846 * @brief Sort the elements of a sequence using a predicate for comparison.
4847 * @ingroup sorting_algorithms
4848 * @param __first An iterator.
4849 * @param __last Another iterator.
4850 * @param __comp A comparison functor.
4851 * @return Nothing.
4852 *
4853 * Sorts the elements in the range @p [__first,__last) in ascending order,
4854 * such that @p __comp(*(i+1),*i) is false for every iterator @e i in the
4855 * range @p [__first,__last-1).
4856 *
4857 * The relative ordering of equivalent elements is not preserved, use
4858 * @p stable_sort() if this is needed.
4859 */
4860 template<typename _RandomAccessIterator, typename _Compare>
4861 _GLIBCXX20_CONSTEXPR
4862 inline void
4863 sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
4864 _Compare __comp)
4865 {
4866 // concept requirements
4867 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
4868 _RandomAccessIterator>)
4869 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
4870 typename iterator_traits<_RandomAccessIterator>::value_type,
4871 typename iterator_traits<_RandomAccessIterator>::value_type>)
4872 __glibcxx_requires_valid_range(__first, __last);
4873 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
4874
4875 std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
4876 }
4877
4878 template<typename _InputIterator1, typename _InputIterator2,
4879 typename _OutputIterator, typename _Compare>
4880 _GLIBCXX20_CONSTEXPR
4881 _OutputIterator
4882 __merge(_InputIterator1 __first1, _InputIterator1 __last1,
4883 _InputIterator2 __first2, _InputIterator2 __last2,
4884 _OutputIterator __result, _Compare __comp)
4885 {
4886 while (__first1 != __last1 && __first2 != __last2)
4887 {
4888 if (__comp(__first2, __first1))
4889 {
4890 *__result = *__first2;
4891 ++__first2;
4892 }
4893 else
4894 {
4895 *__result = *__first1;
4896 ++__first1;
4897 }
4898 ++__result;
4899 }
4900 return std::copy(__first2, __last2,
4901 std::copy(__first1, __last1, __result));
4902 }
4903
4904 /**
4905 * @brief Merges two sorted ranges.
4906 * @ingroup sorting_algorithms
4907 * @param __first1 An iterator.
4908 * @param __first2 Another iterator.
4909 * @param __last1 Another iterator.
4910 * @param __last2 Another iterator.
4911 * @param __result An iterator pointing to the end of the merged range.
4912 * @return An output iterator equal to @p __result + (__last1 - __first1)
4913 * + (__last2 - __first2).
4914 *
4915 * Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
4916 * the sorted range @p [__result, __result + (__last1-__first1) +
4917 * (__last2-__first2)). Both input ranges must be sorted, and the
4918 * output range must not overlap with either of the input ranges.
4919 * The sort is @e stable, that is, for equivalent elements in the
4920 * two ranges, elements from the first range will always come
4921 * before elements from the second.
4922 */
4923 template<typename _InputIterator1, typename _InputIterator2,
4924 typename _OutputIterator>
4925 _GLIBCXX20_CONSTEXPR
4926 inline _OutputIterator
4927 merge(_InputIterator1 __first1, _InputIterator1 __last1,
4928 _InputIterator2 __first2, _InputIterator2 __last2,
4929 _OutputIterator __result)
4930 {
4931 // concept requirements
4932 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
4933 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
4934 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4935 typename iterator_traits<_InputIterator1>::value_type>)
4936 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4937 typename iterator_traits<_InputIterator2>::value_type>)
4938 __glibcxx_function_requires(_LessThanOpConcept<
4939 typename iterator_traits<_InputIterator2>::value_type,
4940 typename iterator_traits<_InputIterator1>::value_type>)
4941 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
4942 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
4943 __glibcxx_requires_irreflexive2(__first1, __last1);
4944 __glibcxx_requires_irreflexive2(__first2, __last2);
4945
4946 return _GLIBCXX_STD_A::__merge(__first1, __last1,
4947 __first2, __last2, __result,
4948 __gnu_cxx::__ops::__iter_less_iter());
4949 }
4950
4951 /**
4952 * @brief Merges two sorted ranges.
4953 * @ingroup sorting_algorithms
4954 * @param __first1 An iterator.
4955 * @param __first2 Another iterator.
4956 * @param __last1 Another iterator.
4957 * @param __last2 Another iterator.
4958 * @param __result An iterator pointing to the end of the merged range.
4959 * @param __comp A functor to use for comparisons.
4960 * @return An output iterator equal to @p __result + (__last1 - __first1)
4961 * + (__last2 - __first2).
4962 *
4963 * Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
4964 * the sorted range @p [__result, __result + (__last1-__first1) +
4965 * (__last2-__first2)). Both input ranges must be sorted, and the
4966 * output range must not overlap with either of the input ranges.
4967 * The sort is @e stable, that is, for equivalent elements in the
4968 * two ranges, elements from the first range will always come
4969 * before elements from the second.
4970 *
4971 * The comparison function should have the same effects on ordering as
4972 * the function used for the initial sort.
4973 */
4974 template<typename _InputIterator1, typename _InputIterator2,
4975 typename _OutputIterator, typename _Compare>
4976 _GLIBCXX20_CONSTEXPR
4977 inline _OutputIterator
4978 merge(_InputIterator1 __first1, _InputIterator1 __last1,
4979 _InputIterator2 __first2, _InputIterator2 __last2,
4980 _OutputIterator __result, _Compare __comp)
4981 {
4982 // concept requirements
4983 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
4984 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
4985 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4986 typename iterator_traits<_InputIterator1>::value_type>)
4987 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
4988 typename iterator_traits<_InputIterator2>::value_type>)
4989 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
4990 typename iterator_traits<_InputIterator2>::value_type,
4991 typename iterator_traits<_InputIterator1>::value_type>)
4992 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
4993 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
4994 __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
4995 __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
4996
4997 return _GLIBCXX_STD_A::__merge(__first1, __last1,
4998 __first2, __last2, __result,
4999 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5000 }
5001
5002 template<typename _RandomAccessIterator, typename _Compare>
5003 inline void
5004 __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
5005 _Compare __comp)
5006 {
5007 typedef typename iterator_traits<_RandomAccessIterator>::value_type
5008 _ValueType;
5009 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
5010 _DistanceType;
5011 typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
5012
5013 if (__first == __last)
5014 return;
5015
5016 // __stable_sort_adaptive sorts the range in two halves,
5017 // so the buffer only needs to fit half the range at once.
5018 _TmpBuf __buf(__first, (__last - __first + 1) / 2);
5019
5020 if (__buf.begin() == 0)
5021 std::__inplace_stable_sort(__first, __last, __comp);
5022 else
5023 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
5024 _DistanceType(__buf.size()), __comp);
5025 }
5026
5027 /**
5028 * @brief Sort the elements of a sequence, preserving the relative order
5029 * of equivalent elements.
5030 * @ingroup sorting_algorithms
5031 * @param __first An iterator.
5032 * @param __last Another iterator.
5033 * @return Nothing.
5034 *
5035 * Sorts the elements in the range @p [__first,__last) in ascending order,
5036 * such that for each iterator @p i in the range @p [__first,__last-1),
5037 * @p *(i+1)<*i is false.
5038 *
5039 * The relative ordering of equivalent elements is preserved, so any two
5040 * elements @p x and @p y in the range @p [__first,__last) such that
5041 * @p x<y is false and @p y<x is false will have the same relative
5042 * ordering after calling @p stable_sort().
5043 */
5044 template<typename _RandomAccessIterator>
5045 inline void
5046 stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
5047 {
5048 // concept requirements
5049 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
5050 _RandomAccessIterator>)
5051 __glibcxx_function_requires(_LessThanComparableConcept<
5052 typename iterator_traits<_RandomAccessIterator>::value_type>)
5053 __glibcxx_requires_valid_range(__first, __last);
5054 __glibcxx_requires_irreflexive(__first, __last);
5055
5056 _GLIBCXX_STD_A::__stable_sort(__first, __last,
5057 __gnu_cxx::__ops::__iter_less_iter());
5058 }
5059
5060 /**
5061 * @brief Sort the elements of a sequence using a predicate for comparison,
5062 * preserving the relative order of equivalent elements.
5063 * @ingroup sorting_algorithms
5064 * @param __first An iterator.
5065 * @param __last Another iterator.
5066 * @param __comp A comparison functor.
5067 * @return Nothing.
5068 *
5069 * Sorts the elements in the range @p [__first,__last) in ascending order,
5070 * such that for each iterator @p i in the range @p [__first,__last-1),
5071 * @p __comp(*(i+1),*i) is false.
5072 *
5073 * The relative ordering of equivalent elements is preserved, so any two
5074 * elements @p x and @p y in the range @p [__first,__last) such that
5075 * @p __comp(x,y) is false and @p __comp(y,x) is false will have the same
5076 * relative ordering after calling @p stable_sort().
5077 */
5078 template<typename _RandomAccessIterator, typename _Compare>
5079 inline void
5080 stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
5081 _Compare __comp)
5082 {
5083 // concept requirements
5084 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
5085 _RandomAccessIterator>)
5086 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5087 typename iterator_traits<_RandomAccessIterator>::value_type,
5088 typename iterator_traits<_RandomAccessIterator>::value_type>)
5089 __glibcxx_requires_valid_range(__first, __last);
5090 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
5091
5092 _GLIBCXX_STD_A::__stable_sort(__first, __last,
5093 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5094 }
5095
5096 template<typename _InputIterator1, typename _InputIterator2,
5097 typename _OutputIterator,
5098 typename _Compare>
5099 _GLIBCXX20_CONSTEXPR
5100 _OutputIterator
5101 __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5102 _InputIterator2 __first2, _InputIterator2 __last2,
5103 _OutputIterator __result, _Compare __comp)
5104 {
5105 while (__first1 != __last1 && __first2 != __last2)
5106 {
5107 if (__comp(__first1, __first2))
5108 {
5109 *__result = *__first1;
5110 ++__first1;
5111 }
5112 else if (__comp(__first2, __first1))
5113 {
5114 *__result = *__first2;
5115 ++__first2;
5116 }
5117 else
5118 {
5119 *__result = *__first1;
5120 ++__first1;
5121 ++__first2;
5122 }
5123 ++__result;
5124 }
5125 return std::copy(__first2, __last2,
5126 std::copy(__first1, __last1, __result));
5127 }
5128
5129 /**
5130 * @brief Return the union of two sorted ranges.
5131 * @ingroup set_algorithms
5132 * @param __first1 Start of first range.
5133 * @param __last1 End of first range.
5134 * @param __first2 Start of second range.
5135 * @param __last2 End of second range.
5136 * @param __result Start of output range.
5137 * @return End of the output range.
5138 * @ingroup set_algorithms
5139 *
5140 * This operation iterates over both ranges, copying elements present in
5141 * each range in order to the output range. Iterators increment for each
5142 * range. When the current element of one range is less than the other,
5143 * that element is copied and the iterator advanced. If an element is
5144 * contained in both ranges, the element from the first range is copied and
5145 * both ranges advance. The output range may not overlap either input
5146 * range.
5147 */
5148 template<typename _InputIterator1, typename _InputIterator2,
5149 typename _OutputIterator>
5150 _GLIBCXX20_CONSTEXPR
5151 inline _OutputIterator
5152 set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5153 _InputIterator2 __first2, _InputIterator2 __last2,
5154 _OutputIterator __result)
5155 {
5156 // concept requirements
5157 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5158 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5159 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5160 typename iterator_traits<_InputIterator1>::value_type>)
5161 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5162 typename iterator_traits<_InputIterator2>::value_type>)
5163 __glibcxx_function_requires(_LessThanOpConcept<
5164 typename iterator_traits<_InputIterator1>::value_type,
5165 typename iterator_traits<_InputIterator2>::value_type>)
5166 __glibcxx_function_requires(_LessThanOpConcept<
5167 typename iterator_traits<_InputIterator2>::value_type,
5168 typename iterator_traits<_InputIterator1>::value_type>)
5169 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
5170 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
5171 __glibcxx_requires_irreflexive2(__first1, __last1);
5172 __glibcxx_requires_irreflexive2(__first2, __last2);
5173
5174 return _GLIBCXX_STD_A::__set_union(__first1, __last1,
5175 __first2, __last2, __result,
5176 __gnu_cxx::__ops::__iter_less_iter());
5177 }
5178
5179 /**
5180 * @brief Return the union of two sorted ranges using a comparison functor.
5181 * @ingroup set_algorithms
5182 * @param __first1 Start of first range.
5183 * @param __last1 End of first range.
5184 * @param __first2 Start of second range.
5185 * @param __last2 End of second range.
5186 * @param __result Start of output range.
5187 * @param __comp The comparison functor.
5188 * @return End of the output range.
5189 * @ingroup set_algorithms
5190 *
5191 * This operation iterates over both ranges, copying elements present in
5192 * each range in order to the output range. Iterators increment for each
5193 * range. When the current element of one range is less than the other
5194 * according to @p __comp, that element is copied and the iterator advanced.
5195 * If an equivalent element according to @p __comp is contained in both
5196 * ranges, the element from the first range is copied and both ranges
5197 * advance. The output range may not overlap either input range.
5198 */
5199 template<typename _InputIterator1, typename _InputIterator2,
5200 typename _OutputIterator, typename _Compare>
5201 _GLIBCXX20_CONSTEXPR
5202 inline _OutputIterator
5203 set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5204 _InputIterator2 __first2, _InputIterator2 __last2,
5205 _OutputIterator __result, _Compare __comp)
5206 {
5207 // concept requirements
5208 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5209 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5210 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5211 typename iterator_traits<_InputIterator1>::value_type>)
5212 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5213 typename iterator_traits<_InputIterator2>::value_type>)
5214 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5215 typename iterator_traits<_InputIterator1>::value_type,
5216 typename iterator_traits<_InputIterator2>::value_type>)
5217 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5218 typename iterator_traits<_InputIterator2>::value_type,
5219 typename iterator_traits<_InputIterator1>::value_type>)
5220 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
5221 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
5222 __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
5223 __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
5224
5225 return _GLIBCXX_STD_A::__set_union(__first1, __last1,
5226 __first2, __last2, __result,
5227 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5228 }
5229
5230 template<typename _InputIterator1, typename _InputIterator2,
5231 typename _OutputIterator,
5232 typename _Compare>
5233 _GLIBCXX20_CONSTEXPR
5234 _OutputIterator
5235 __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5236 _InputIterator2 __first2, _InputIterator2 __last2,
5237 _OutputIterator __result, _Compare __comp)
5238 {
5239 while (__first1 != __last1 && __first2 != __last2)
5240 if (__comp(__first1, __first2))
5241 ++__first1;
5242 else if (__comp(__first2, __first1))
5243 ++__first2;
5244 else
5245 {
5246 *__result = *__first1;
5247 ++__first1;
5248 ++__first2;
5249 ++__result;
5250 }
5251 return __result;
5252 }
5253
5254 /**
5255 * @brief Return the intersection of two sorted ranges.
5256 * @ingroup set_algorithms
5257 * @param __first1 Start of first range.
5258 * @param __last1 End of first range.
5259 * @param __first2 Start of second range.
5260 * @param __last2 End of second range.
5261 * @param __result Start of output range.
5262 * @return End of the output range.
5263 * @ingroup set_algorithms
5264 *
5265 * This operation iterates over both ranges, copying elements present in
5266 * both ranges in order to the output range. Iterators increment for each
5267 * range. When the current element of one range is less than the other,
5268 * that iterator advances. If an element is contained in both ranges, the
5269 * element from the first range is copied and both ranges advance. The
5270 * output range may not overlap either input range.
5271 */
5272 template<typename _InputIterator1, typename _InputIterator2,
5273 typename _OutputIterator>
5274 _GLIBCXX20_CONSTEXPR
5275 inline _OutputIterator
5276 set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5277 _InputIterator2 __first2, _InputIterator2 __last2,
5278 _OutputIterator __result)
5279 {
5280 // concept requirements
5281 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5282 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5283 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5284 typename iterator_traits<_InputIterator1>::value_type>)
5285 __glibcxx_function_requires(_LessThanOpConcept<
5286 typename iterator_traits<_InputIterator1>::value_type,
5287 typename iterator_traits<_InputIterator2>::value_type>)
5288 __glibcxx_function_requires(_LessThanOpConcept<
5289 typename iterator_traits<_InputIterator2>::value_type,
5290 typename iterator_traits<_InputIterator1>::value_type>)
5291 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
5292 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
5293 __glibcxx_requires_irreflexive2(__first1, __last1);
5294 __glibcxx_requires_irreflexive2(__first2, __last2);
5295
5296 return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,
5297 __first2, __last2, __result,
5298 __gnu_cxx::__ops::__iter_less_iter());
5299 }
5300
5301 /**
5302 * @brief Return the intersection of two sorted ranges using comparison
5303 * functor.
5304 * @ingroup set_algorithms
5305 * @param __first1 Start of first range.
5306 * @param __last1 End of first range.
5307 * @param __first2 Start of second range.
5308 * @param __last2 End of second range.
5309 * @param __result Start of output range.
5310 * @param __comp The comparison functor.
5311 * @return End of the output range.
5312 * @ingroup set_algorithms
5313 *
5314 * This operation iterates over both ranges, copying elements present in
5315 * both ranges in order to the output range. Iterators increment for each
5316 * range. When the current element of one range is less than the other
5317 * according to @p __comp, that iterator advances. If an element is
5318 * contained in both ranges according to @p __comp, the element from the
5319 * first range is copied and both ranges advance. The output range may not
5320 * overlap either input range.
5321 */
5322 template<typename _InputIterator1, typename _InputIterator2,
5323 typename _OutputIterator, typename _Compare>
5324 _GLIBCXX20_CONSTEXPR
5325 inline _OutputIterator
5326 set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5327 _InputIterator2 __first2, _InputIterator2 __last2,
5328 _OutputIterator __result, _Compare __comp)
5329 {
5330 // concept requirements
5331 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5332 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5333 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5334 typename iterator_traits<_InputIterator1>::value_type>)
5335 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5336 typename iterator_traits<_InputIterator1>::value_type,
5337 typename iterator_traits<_InputIterator2>::value_type>)
5338 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5339 typename iterator_traits<_InputIterator2>::value_type,
5340 typename iterator_traits<_InputIterator1>::value_type>)
5341 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
5342 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
5343 __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
5344 __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
5345
5346 return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,
5347 __first2, __last2, __result,
5348 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5349 }
5350
5351 template<typename _InputIterator1, typename _InputIterator2,
5352 typename _OutputIterator,
5353 typename _Compare>
5354 _GLIBCXX20_CONSTEXPR
5355 _OutputIterator
5356 __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5357 _InputIterator2 __first2, _InputIterator2 __last2,
5358 _OutputIterator __result, _Compare __comp)
5359 {
5360 while (__first1 != __last1 && __first2 != __last2)
5361 if (__comp(__first1, __first2))
5362 {
5363 *__result = *__first1;
5364 ++__first1;
5365 ++__result;
5366 }
5367 else if (__comp(__first2, __first1))
5368 ++__first2;
5369 else
5370 {
5371 ++__first1;
5372 ++__first2;
5373 }
5374 return std::copy(__first1, __last1, __result);
5375 }
5376
5377 /**
5378 * @brief Return the difference of two sorted ranges.
5379 * @ingroup set_algorithms
5380 * @param __first1 Start of first range.
5381 * @param __last1 End of first range.
5382 * @param __first2 Start of second range.
5383 * @param __last2 End of second range.
5384 * @param __result Start of output range.
5385 * @return End of the output range.
5386 * @ingroup set_algorithms
5387 *
5388 * This operation iterates over both ranges, copying elements present in
5389 * the first range but not the second in order to the output range.
5390 * Iterators increment for each range. When the current element of the
5391 * first range is less than the second, that element is copied and the
5392 * iterator advances. If the current element of the second range is less,
5393 * the iterator advances, but no element is copied. If an element is
5394 * contained in both ranges, no elements are copied and both ranges
5395 * advance. The output range may not overlap either input range.
5396 */
5397 template<typename _InputIterator1, typename _InputIterator2,
5398 typename _OutputIterator>
5399 _GLIBCXX20_CONSTEXPR
5400 inline _OutputIterator
5401 set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5402 _InputIterator2 __first2, _InputIterator2 __last2,
5403 _OutputIterator __result)
5404 {
5405 // concept requirements
5406 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5407 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5408 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5409 typename iterator_traits<_InputIterator1>::value_type>)
5410 __glibcxx_function_requires(_LessThanOpConcept<
5411 typename iterator_traits<_InputIterator1>::value_type,
5412 typename iterator_traits<_InputIterator2>::value_type>)
5413 __glibcxx_function_requires(_LessThanOpConcept<
5414 typename iterator_traits<_InputIterator2>::value_type,
5415 typename iterator_traits<_InputIterator1>::value_type>)
5416 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
5417 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
5418 __glibcxx_requires_irreflexive2(__first1, __last1);
5419 __glibcxx_requires_irreflexive2(__first2, __last2);
5420
5421 return _GLIBCXX_STD_A::__set_difference(__first1, __last1,
5422 __first2, __last2, __result,
5423 __gnu_cxx::__ops::__iter_less_iter());
5424 }
5425
5426 /**
5427 * @brief Return the difference of two sorted ranges using comparison
5428 * functor.
5429 * @ingroup set_algorithms
5430 * @param __first1 Start of first range.
5431 * @param __last1 End of first range.
5432 * @param __first2 Start of second range.
5433 * @param __last2 End of second range.
5434 * @param __result Start of output range.
5435 * @param __comp The comparison functor.
5436 * @return End of the output range.
5437 * @ingroup set_algorithms
5438 *
5439 * This operation iterates over both ranges, copying elements present in
5440 * the first range but not the second in order to the output range.
5441 * Iterators increment for each range. When the current element of the
5442 * first range is less than the second according to @p __comp, that element
5443 * is copied and the iterator advances. If the current element of the
5444 * second range is less, no element is copied and the iterator advances.
5445 * If an element is contained in both ranges according to @p __comp, no
5446 * elements are copied and both ranges advance. The output range may not
5447 * overlap either input range.
5448 */
5449 template<typename _InputIterator1, typename _InputIterator2,
5450 typename _OutputIterator, typename _Compare>
5451 _GLIBCXX20_CONSTEXPR
5452 inline _OutputIterator
5453 set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5454 _InputIterator2 __first2, _InputIterator2 __last2,
5455 _OutputIterator __result, _Compare __comp)
5456 {
5457 // concept requirements
5458 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5459 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5460 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5461 typename iterator_traits<_InputIterator1>::value_type>)
5462 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5463 typename iterator_traits<_InputIterator1>::value_type,
5464 typename iterator_traits<_InputIterator2>::value_type>)
5465 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5466 typename iterator_traits<_InputIterator2>::value_type,
5467 typename iterator_traits<_InputIterator1>::value_type>)
5468 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
5469 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
5470 __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
5471 __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
5472
5473 return _GLIBCXX_STD_A::__set_difference(__first1, __last1,
5474 __first2, __last2, __result,
5475 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5476 }
5477
5478 template<typename _InputIterator1, typename _InputIterator2,
5479 typename _OutputIterator,
5480 typename _Compare>
5481 _GLIBCXX20_CONSTEXPR
5482 _OutputIterator
5483 __set_symmetric_difference(_InputIterator1 __first1,
5484 _InputIterator1 __last1,
5485 _InputIterator2 __first2,
5486 _InputIterator2 __last2,
5487 _OutputIterator __result,
5488 _Compare __comp)
5489 {
5490 while (__first1 != __last1 && __first2 != __last2)
5491 if (__comp(__first1, __first2))
5492 {
5493 *__result = *__first1;
5494 ++__first1;
5495 ++__result;
5496 }
5497 else if (__comp(__first2, __first1))
5498 {
5499 *__result = *__first2;
5500 ++__first2;
5501 ++__result;
5502 }
5503 else
5504 {
5505 ++__first1;
5506 ++__first2;
5507 }
5508 return std::copy(__first2, __last2,
5509 std::copy(__first1, __last1, __result));
5510 }
5511
5512 /**
5513 * @brief Return the symmetric difference of two sorted ranges.
5514 * @ingroup set_algorithms
5515 * @param __first1 Start of first range.
5516 * @param __last1 End of first range.
5517 * @param __first2 Start of second range.
5518 * @param __last2 End of second range.
5519 * @param __result Start of output range.
5520 * @return End of the output range.
5521 * @ingroup set_algorithms
5522 *
5523 * This operation iterates over both ranges, copying elements present in
5524 * one range but not the other in order to the output range. Iterators
5525 * increment for each range. When the current element of one range is less
5526 * than the other, that element is copied and the iterator advances. If an
5527 * element is contained in both ranges, no elements are copied and both
5528 * ranges advance. The output range may not overlap either input range.
5529 */
5530 template<typename _InputIterator1, typename _InputIterator2,
5531 typename _OutputIterator>
5532 _GLIBCXX20_CONSTEXPR
5533 inline _OutputIterator
5534 set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5535 _InputIterator2 __first2, _InputIterator2 __last2,
5536 _OutputIterator __result)
5537 {
5538 // concept requirements
5539 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5540 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5541 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5542 typename iterator_traits<_InputIterator1>::value_type>)
5543 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5544 typename iterator_traits<_InputIterator2>::value_type>)
5545 __glibcxx_function_requires(_LessThanOpConcept<
5546 typename iterator_traits<_InputIterator1>::value_type,
5547 typename iterator_traits<_InputIterator2>::value_type>)
5548 __glibcxx_function_requires(_LessThanOpConcept<
5549 typename iterator_traits<_InputIterator2>::value_type,
5550 typename iterator_traits<_InputIterator1>::value_type>)
5551 __glibcxx_requires_sorted_set(__first1, __last1, __first2);
5552 __glibcxx_requires_sorted_set(__first2, __last2, __first1);
5553 __glibcxx_requires_irreflexive2(__first1, __last1);
5554 __glibcxx_requires_irreflexive2(__first2, __last2);
5555
5556 return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,
5557 __first2, __last2, __result,
5558 __gnu_cxx::__ops::__iter_less_iter());
5559 }
5560
5561 /**
5562 * @brief Return the symmetric difference of two sorted ranges using
5563 * comparison functor.
5564 * @ingroup set_algorithms
5565 * @param __first1 Start of first range.
5566 * @param __last1 End of first range.
5567 * @param __first2 Start of second range.
5568 * @param __last2 End of second range.
5569 * @param __result Start of output range.
5570 * @param __comp The comparison functor.
5571 * @return End of the output range.
5572 * @ingroup set_algorithms
5573 *
5574 * This operation iterates over both ranges, copying elements present in
5575 * one range but not the other in order to the output range. Iterators
5576 * increment for each range. When the current element of one range is less
5577 * than the other according to @p comp, that element is copied and the
5578 * iterator advances. If an element is contained in both ranges according
5579 * to @p __comp, no elements are copied and both ranges advance. The output
5580 * range may not overlap either input range.
5581 */
5582 template<typename _InputIterator1, typename _InputIterator2,
5583 typename _OutputIterator, typename _Compare>
5584 _GLIBCXX20_CONSTEXPR
5585 inline _OutputIterator
5586 set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5587 _InputIterator2 __first2, _InputIterator2 __last2,
5588 _OutputIterator __result,
5589 _Compare __comp)
5590 {
5591 // concept requirements
5592 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
5593 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
5594 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5595 typename iterator_traits<_InputIterator1>::value_type>)
5596 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
5597 typename iterator_traits<_InputIterator2>::value_type>)
5598 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5599 typename iterator_traits<_InputIterator1>::value_type,
5600 typename iterator_traits<_InputIterator2>::value_type>)
5601 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5602 typename iterator_traits<_InputIterator2>::value_type,
5603 typename iterator_traits<_InputIterator1>::value_type>)
5604 __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
5605 __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
5606 __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
5607 __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
5608
5609 return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,
5610 __first2, __last2, __result,
5611 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5612 }
5613
5614 template<typename _ForwardIterator, typename _Compare>
5615 _GLIBCXX14_CONSTEXPR
5616 _ForwardIterator
5617 __min_element(_ForwardIterator __first, _ForwardIterator __last,
5618 _Compare __comp)
5619 {
5620 if (__first == __last)
5621 return __first;
5622 _ForwardIterator __result = __first;
5623 while (++__first != __last)
5624 if (__comp(__first, __result))
5625 __result = __first;
5626 return __result;
5627 }
5628
5629 /**
5630 * @brief Return the minimum element in a range.
5631 * @ingroup sorting_algorithms
5632 * @param __first Start of range.
5633 * @param __last End of range.
5634 * @return Iterator referencing the first instance of the smallest value.
5635 */
5636 template<typename _ForwardIterator>
5637 _GLIBCXX14_CONSTEXPR
5638 _ForwardIterator
5639 inline min_element(_ForwardIterator __first, _ForwardIterator __last)
5640 {
5641 // concept requirements
5642 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
5643 __glibcxx_function_requires(_LessThanComparableConcept<
5644 typename iterator_traits<_ForwardIterator>::value_type>)
5645 __glibcxx_requires_valid_range(__first, __last);
5646 __glibcxx_requires_irreflexive(__first, __last);
5647
5648 return _GLIBCXX_STD_A::__min_element(__first, __last,
5649 __gnu_cxx::__ops::__iter_less_iter());
5650 }
5651
5652 /**
5653 * @brief Return the minimum element in a range using comparison functor.
5654 * @ingroup sorting_algorithms
5655 * @param __first Start of range.
5656 * @param __last End of range.
5657 * @param __comp Comparison functor.
5658 * @return Iterator referencing the first instance of the smallest value
5659 * according to __comp.
5660 */
5661 template<typename _ForwardIterator, typename _Compare>
5662 _GLIBCXX14_CONSTEXPR
5663 inline _ForwardIterator
5664 min_element(_ForwardIterator __first, _ForwardIterator __last,
5665 _Compare __comp)
5666 {
5667 // concept requirements
5668 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
5669 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5670 typename iterator_traits<_ForwardIterator>::value_type,
5671 typename iterator_traits<_ForwardIterator>::value_type>)
5672 __glibcxx_requires_valid_range(__first, __last);
5673 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
5674
5675 return _GLIBCXX_STD_A::__min_element(__first, __last,
5676 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5677 }
5678
5679 template<typename _ForwardIterator, typename _Compare>
5680 _GLIBCXX14_CONSTEXPR
5681 _ForwardIterator
5682 __max_element(_ForwardIterator __first, _ForwardIterator __last,
5683 _Compare __comp)
5684 {
5685 if (__first == __last) return __first;
5686 _ForwardIterator __result = __first;
5687 while (++__first != __last)
5688 if (__comp(__result, __first))
5689 __result = __first;
5690 return __result;
5691 }
5692
5693 /**
5694 * @brief Return the maximum element in a range.
5695 * @ingroup sorting_algorithms
5696 * @param __first Start of range.
5697 * @param __last End of range.
5698 * @return Iterator referencing the first instance of the largest value.
5699 */
5700 template<typename _ForwardIterator>
5701 _GLIBCXX14_CONSTEXPR
5702 inline _ForwardIterator
5703 max_element(_ForwardIterator __first, _ForwardIterator __last)
5704 {
5705 // concept requirements
5706 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
5707 __glibcxx_function_requires(_LessThanComparableConcept<
5708 typename iterator_traits<_ForwardIterator>::value_type>)
5709 __glibcxx_requires_valid_range(__first, __last);
5710 __glibcxx_requires_irreflexive(__first, __last);
5711
5712 return _GLIBCXX_STD_A::__max_element(__first, __last,
5713 __gnu_cxx::__ops::__iter_less_iter());
5714 }
5715
5716 /**
5717 * @brief Return the maximum element in a range using comparison functor.
5718 * @ingroup sorting_algorithms
5719 * @param __first Start of range.
5720 * @param __last End of range.
5721 * @param __comp Comparison functor.
5722 * @return Iterator referencing the first instance of the largest value
5723 * according to __comp.
5724 */
5725 template<typename _ForwardIterator, typename _Compare>
5726 _GLIBCXX14_CONSTEXPR
5727 inline _ForwardIterator
5728 max_element(_ForwardIterator __first, _ForwardIterator __last,
5729 _Compare __comp)
5730 {
5731 // concept requirements
5732 __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
5733 __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
5734 typename iterator_traits<_ForwardIterator>::value_type,
5735 typename iterator_traits<_ForwardIterator>::value_type>)
5736 __glibcxx_requires_valid_range(__first, __last);
5737 __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
5738
5739 return _GLIBCXX_STD_A::__max_element(__first, __last,
5740 __gnu_cxx::__ops::__iter_comp_iter(__comp));
5741 }
5742
5743#if __cplusplus >= 201402L
5744 /// Reservoir sampling algorithm.
5745 template<typename _InputIterator, typename _RandomAccessIterator,
5746 typename _Size, typename _UniformRandomBitGenerator>
5747 _RandomAccessIterator
5748 __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
5749 _RandomAccessIterator __out, random_access_iterator_tag,
5750 _Size __n, _UniformRandomBitGenerator&& __g)
5751 {
5752 using __distrib_type = uniform_int_distribution<_Size>;
5753 using __param_type = typename __distrib_type::param_type;
5754 __distrib_type __d{};
5755 _Size __sample_sz = 0;
5756 while (__first != __last && __sample_sz != __n)
5757 {
5758 __out[__sample_sz++] = *__first;
5759 ++__first;
5760 }
5761 for (auto __pop_sz = __sample_sz; __first != __last;
5762 ++__first, (void) ++__pop_sz)
5763 {
5764 const auto __k = __d(__g, __param_type{0, __pop_sz});
5765 if (__k < __n)
5766 __out[__k] = *__first;
5767 }
5768 return __out + __sample_sz;
5769 }
5770
5771 /// Selection sampling algorithm.
5772 template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
5773 typename _Size, typename _UniformRandomBitGenerator>
5774 _OutputIterator
5775 __sample(_ForwardIterator __first, _ForwardIterator __last,
5776 forward_iterator_tag,
5777 _OutputIterator __out, _Cat,
5778 _Size __n, _UniformRandomBitGenerator&& __g)
5779 {
5780 using __distrib_type = uniform_int_distribution<_Size>;
5781 using __param_type = typename __distrib_type::param_type;
5782 using _USize = make_unsigned_t<_Size>;
5783 using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
5784 using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
5785
5786 if (__first == __last)
5787 return __out;
5788
5789 __distrib_type __d{};
5790 _Size __unsampled_sz = std::distance(__first, __last);
5791 __n = std::min(__n, __unsampled_sz);
5792
5793 // If possible, we use __gen_two_uniform_ints to efficiently produce
5794 // two random numbers using a single distribution invocation:
5795
5796 const __uc_type __urngrange = __g.max() - __g.min();
5797 if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
5798 // I.e. (__urngrange >= __unsampled_sz * __unsampled_sz) but without
5799 // wrapping issues.
5800 {
5801 while (__n != 0 && __unsampled_sz >= 2)
5802 {
5803 const pair<_Size, _Size> __p =
5804 __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);
5805
5806 --__unsampled_sz;
5807 if (__p.first < __n)
5808 {
5809 *__out++ = *__first;
5810 --__n;
5811 }
5812
5813 ++__first;
5814
5815 if (__n == 0) break;
5816
5817 --__unsampled_sz;
5818 if (__p.second < __n)
5819 {
5820 *__out++ = *__first;
5821 --__n;
5822 }
5823
5824 ++__first;
5825 }
5826 }
5827
5828 // The loop above is otherwise equivalent to this one-at-a-time version:
5829
5830 for (; __n != 0; ++__first)
5831 if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
5832 {
5833 *__out++ = *__first;
5834 --__n;
5835 }
5836 return __out;
5837 }
5838
5839#if __cplusplus > 201402L
5840#define __cpp_lib_sample 201603
5841 /// Take a random sample from a population.
5842 template<typename _PopulationIterator, typename _SampleIterator,
5843 typename _Distance, typename _UniformRandomBitGenerator>
5844 _SampleIterator
5845 sample(_PopulationIterator __first, _PopulationIterator __last,
5846 _SampleIterator __out, _Distance __n,
5847 _UniformRandomBitGenerator&& __g)
5848 {
5849 using __pop_cat = typename
5850 std::iterator_traits<_PopulationIterator>::iterator_category;
5851 using __samp_cat = typename
5852 std::iterator_traits<_SampleIterator>::iterator_category;
5853
5854 static_assert(
5855 __or_<is_convertible<__pop_cat, forward_iterator_tag>,
5856 is_convertible<__samp_cat, random_access_iterator_tag>>::value,
5857 "output range must use a RandomAccessIterator when input range"
5858 " does not meet the ForwardIterator requirements");
5859
5860 static_assert(is_integral<_Distance>::value,
5861 "sample size must be an integer type");
5862
5863 typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
5864 return _GLIBCXX_STD_A::
5865 __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
5866 std::forward<_UniformRandomBitGenerator>(__g));
5867 }
5868#endif // C++17
5869#endif // C++14
5870
5871_GLIBCXX_END_NAMESPACE_ALGO
5872_GLIBCXX_END_NAMESPACE_VERSION
5873} // namespace std
5874
5875#endif /* _STL_ALGO_H */
Note: See TracBrowser for help on using the repository browser.