17a984708SDavid Chisnall// -*- C++ -*- 27a984708SDavid Chisnall//===-------------------------- algorithm ---------------------------------===// 37a984708SDavid Chisnall// 47a984708SDavid Chisnall// The LLVM Compiler Infrastructure 57a984708SDavid Chisnall// 67a984708SDavid Chisnall// This file is dual licensed under the MIT and the University of Illinois Open 77a984708SDavid Chisnall// Source Licenses. See LICENSE.TXT for details. 87a984708SDavid Chisnall// 97a984708SDavid Chisnall//===----------------------------------------------------------------------===// 107a984708SDavid Chisnall 117a984708SDavid Chisnall#ifndef _LIBCPP_ALGORITHM 127a984708SDavid Chisnall#define _LIBCPP_ALGORITHM 137a984708SDavid Chisnall 147a984708SDavid Chisnall/* 157a984708SDavid Chisnall algorithm synopsis 167a984708SDavid Chisnall 177a984708SDavid Chisnall#include <initializer_list> 187a984708SDavid Chisnall 197a984708SDavid Chisnallnamespace std 207a984708SDavid Chisnall{ 217a984708SDavid Chisnall 227a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 237a984708SDavid Chisnall bool 247a984708SDavid Chisnall all_of(InputIterator first, InputIterator last, Predicate pred); 257a984708SDavid Chisnall 267a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 277a984708SDavid Chisnall bool 287a984708SDavid Chisnall any_of(InputIterator first, InputIterator last, Predicate pred); 297a984708SDavid Chisnall 307a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 317a984708SDavid Chisnall bool 327a984708SDavid Chisnall none_of(InputIterator first, InputIterator last, Predicate pred); 337a984708SDavid Chisnall 347a984708SDavid Chisnalltemplate <class InputIterator, class Function> 357a984708SDavid Chisnall Function 367a984708SDavid Chisnall for_each(InputIterator first, InputIterator last, Function f); 377a984708SDavid Chisnall 387a984708SDavid Chisnalltemplate <class InputIterator, class T> 397a984708SDavid Chisnall InputIterator 407a984708SDavid Chisnall find(InputIterator first, InputIterator last, const T& value); 417a984708SDavid Chisnall 427a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 437a984708SDavid Chisnall InputIterator 447a984708SDavid Chisnall find_if(InputIterator first, InputIterator last, Predicate pred); 457a984708SDavid Chisnall 467a984708SDavid Chisnalltemplate<class InputIterator, class Predicate> 477a984708SDavid Chisnall InputIterator 487a984708SDavid Chisnall find_if_not(InputIterator first, InputIterator last, Predicate pred); 497a984708SDavid Chisnall 507a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 517a984708SDavid Chisnall ForwardIterator1 527a984708SDavid Chisnall find_end(ForwardIterator1 first1, ForwardIterator1 last1, 537a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2); 547a984708SDavid Chisnall 557a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 567a984708SDavid Chisnall ForwardIterator1 577a984708SDavid Chisnall find_end(ForwardIterator1 first1, ForwardIterator1 last1, 587a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 597a984708SDavid Chisnall 607a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 617a984708SDavid Chisnall ForwardIterator1 627a984708SDavid Chisnall find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 637a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2); 647a984708SDavid Chisnall 657a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 667a984708SDavid Chisnall ForwardIterator1 677a984708SDavid Chisnall find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 687a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 697a984708SDavid Chisnall 707a984708SDavid Chisnalltemplate <class ForwardIterator> 717a984708SDavid Chisnall ForwardIterator 727a984708SDavid Chisnall adjacent_find(ForwardIterator first, ForwardIterator last); 737a984708SDavid Chisnall 747a984708SDavid Chisnalltemplate <class ForwardIterator, class BinaryPredicate> 757a984708SDavid Chisnall ForwardIterator 767a984708SDavid Chisnall adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 777a984708SDavid Chisnall 787a984708SDavid Chisnalltemplate <class InputIterator, class T> 797a984708SDavid Chisnall typename iterator_traits<InputIterator>::difference_type 807a984708SDavid Chisnall count(InputIterator first, InputIterator last, const T& value); 817a984708SDavid Chisnall 827a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 837a984708SDavid Chisnall typename iterator_traits<InputIterator>::difference_type 847a984708SDavid Chisnall count_if(InputIterator first, InputIterator last, Predicate pred); 857a984708SDavid Chisnall 867a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 877a984708SDavid Chisnall pair<InputIterator1, InputIterator2> 887a984708SDavid Chisnall mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 897a984708SDavid Chisnall 904bab9fd9SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 914bab9fd9SDavid Chisnall pair<InputIterator1, InputIterator2> 924bab9fd9SDavid Chisnall mismatch(InputIterator1 first1, InputIterator1 last1, 934bab9fd9SDavid Chisnall InputIterator2 first2, InputIterator2 last2); // **C++14** 944bab9fd9SDavid Chisnall 957a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 967a984708SDavid Chisnall pair<InputIterator1, InputIterator2> 977a984708SDavid Chisnall mismatch(InputIterator1 first1, InputIterator1 last1, 987a984708SDavid Chisnall InputIterator2 first2, BinaryPredicate pred); 997a984708SDavid Chisnall 1004bab9fd9SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 1014bab9fd9SDavid Chisnall pair<InputIterator1, InputIterator2> 1024bab9fd9SDavid Chisnall mismatch(InputIterator1 first1, InputIterator1 last1, 1034bab9fd9SDavid Chisnall InputIterator2 first2, InputIterator2 last2, 1044bab9fd9SDavid Chisnall BinaryPredicate pred); // **C++14** 1054bab9fd9SDavid Chisnall 1067a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 1077a984708SDavid Chisnall bool 1087a984708SDavid Chisnall equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 1097a984708SDavid Chisnall 1104bab9fd9SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 1114bab9fd9SDavid Chisnall bool 1124bab9fd9SDavid Chisnall equal(InputIterator1 first1, InputIterator1 last1, 1134bab9fd9SDavid Chisnall InputIterator2 first2, InputIterator2 last2); // **C++14** 1144bab9fd9SDavid Chisnall 1157a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 1167a984708SDavid Chisnall bool 1177a984708SDavid Chisnall equal(InputIterator1 first1, InputIterator1 last1, 1187a984708SDavid Chisnall InputIterator2 first2, BinaryPredicate pred); 1197a984708SDavid Chisnall 1204bab9fd9SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 1214bab9fd9SDavid Chisnall bool 1224bab9fd9SDavid Chisnall equal(InputIterator1 first1, InputIterator1 last1, 1234bab9fd9SDavid Chisnall InputIterator2 first2, InputIterator2 last2, 1244bab9fd9SDavid Chisnall BinaryPredicate pred); // **C++14** 1254bab9fd9SDavid Chisnall 1267a984708SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2> 1277a984708SDavid Chisnall bool 1287a984708SDavid Chisnall is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 1297a984708SDavid Chisnall ForwardIterator2 first2); 1307a984708SDavid Chisnall 1314bab9fd9SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2> 1324bab9fd9SDavid Chisnall bool 1334bab9fd9SDavid Chisnall is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 1344bab9fd9SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2); // **C++14** 1354bab9fd9SDavid Chisnall 1367a984708SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 1377a984708SDavid Chisnall bool 1387a984708SDavid Chisnall is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 1397a984708SDavid Chisnall ForwardIterator2 first2, BinaryPredicate pred); 1407a984708SDavid Chisnall 1414bab9fd9SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 1424bab9fd9SDavid Chisnall bool 1434bab9fd9SDavid Chisnall is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 1444bab9fd9SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2, 1454bab9fd9SDavid Chisnall BinaryPredicate pred); // **C++14** 1464bab9fd9SDavid Chisnall 1477a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 1487a984708SDavid Chisnall ForwardIterator1 1497a984708SDavid Chisnall search(ForwardIterator1 first1, ForwardIterator1 last1, 1507a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2); 1517a984708SDavid Chisnall 1527a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 1537a984708SDavid Chisnall ForwardIterator1 1547a984708SDavid Chisnall search(ForwardIterator1 first1, ForwardIterator1 last1, 1557a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 1567a984708SDavid Chisnall 1577a984708SDavid Chisnalltemplate <class ForwardIterator, class Size, class T> 1587a984708SDavid Chisnall ForwardIterator 1597a984708SDavid Chisnall search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); 1607a984708SDavid Chisnall 1617a984708SDavid Chisnalltemplate <class ForwardIterator, class Size, class T, class BinaryPredicate> 1627a984708SDavid Chisnall ForwardIterator 1637a984708SDavid Chisnall search_n(ForwardIterator first, ForwardIterator last, 1647a984708SDavid Chisnall Size count, const T& value, BinaryPredicate pred); 1657a984708SDavid Chisnall 1667a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator> 1677a984708SDavid Chisnall OutputIterator 1687a984708SDavid Chisnall copy(InputIterator first, InputIterator last, OutputIterator result); 1697a984708SDavid Chisnall 1707a984708SDavid Chisnalltemplate<class InputIterator, class OutputIterator, class Predicate> 1717a984708SDavid Chisnall OutputIterator 1727a984708SDavid Chisnall copy_if(InputIterator first, InputIterator last, 1737a984708SDavid Chisnall OutputIterator result, Predicate pred); 1747a984708SDavid Chisnall 1757a984708SDavid Chisnalltemplate<class InputIterator, class Size, class OutputIterator> 1767a984708SDavid Chisnall OutputIterator 1777a984708SDavid Chisnall copy_n(InputIterator first, Size n, OutputIterator result); 1787a984708SDavid Chisnall 1797a984708SDavid Chisnalltemplate <class BidirectionalIterator1, class BidirectionalIterator2> 1807a984708SDavid Chisnall BidirectionalIterator2 1817a984708SDavid Chisnall copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 1827a984708SDavid Chisnall BidirectionalIterator2 result); 1837a984708SDavid Chisnall 1847a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 1857a984708SDavid Chisnall ForwardIterator2 1867a984708SDavid Chisnall swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); 1877a984708SDavid Chisnall 1887a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 1897a984708SDavid Chisnall void 1907a984708SDavid Chisnall iter_swap(ForwardIterator1 a, ForwardIterator2 b); 1917a984708SDavid Chisnall 1927a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class UnaryOperation> 1937a984708SDavid Chisnall OutputIterator 1947a984708SDavid Chisnall transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); 1957a984708SDavid Chisnall 1967a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> 1977a984708SDavid Chisnall OutputIterator 1987a984708SDavid Chisnall transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, 1997a984708SDavid Chisnall OutputIterator result, BinaryOperation binary_op); 2007a984708SDavid Chisnall 2017a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 2027a984708SDavid Chisnall void 2037a984708SDavid Chisnall replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); 2047a984708SDavid Chisnall 2057a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate, class T> 2067a984708SDavid Chisnall void 2077a984708SDavid Chisnall replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); 2087a984708SDavid Chisnall 2097a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class T> 2107a984708SDavid Chisnall OutputIterator 2117a984708SDavid Chisnall replace_copy(InputIterator first, InputIterator last, OutputIterator result, 2127a984708SDavid Chisnall const T& old_value, const T& new_value); 2137a984708SDavid Chisnall 2147a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class Predicate, class T> 2157a984708SDavid Chisnall OutputIterator 2167a984708SDavid Chisnall replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value); 2177a984708SDavid Chisnall 2187a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 2197a984708SDavid Chisnall void 2207a984708SDavid Chisnall fill(ForwardIterator first, ForwardIterator last, const T& value); 2217a984708SDavid Chisnall 2227a984708SDavid Chisnalltemplate <class OutputIterator, class Size, class T> 2237a984708SDavid Chisnall OutputIterator 2247a984708SDavid Chisnall fill_n(OutputIterator first, Size n, const T& value); 2257a984708SDavid Chisnall 2267a984708SDavid Chisnalltemplate <class ForwardIterator, class Generator> 2277a984708SDavid Chisnall void 2287a984708SDavid Chisnall generate(ForwardIterator first, ForwardIterator last, Generator gen); 2297a984708SDavid Chisnall 2307a984708SDavid Chisnalltemplate <class OutputIterator, class Size, class Generator> 2317a984708SDavid Chisnall OutputIterator 2327a984708SDavid Chisnall generate_n(OutputIterator first, Size n, Generator gen); 2337a984708SDavid Chisnall 2347a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 2357a984708SDavid Chisnall ForwardIterator 2367a984708SDavid Chisnall remove(ForwardIterator first, ForwardIterator last, const T& value); 2377a984708SDavid Chisnall 2387a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate> 2397a984708SDavid Chisnall ForwardIterator 2407a984708SDavid Chisnall remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); 2417a984708SDavid Chisnall 2427a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class T> 2437a984708SDavid Chisnall OutputIterator 2447a984708SDavid Chisnall remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); 2457a984708SDavid Chisnall 2467a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class Predicate> 2477a984708SDavid Chisnall OutputIterator 2487a984708SDavid Chisnall remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); 2497a984708SDavid Chisnall 2507a984708SDavid Chisnalltemplate <class ForwardIterator> 2517a984708SDavid Chisnall ForwardIterator 2527a984708SDavid Chisnall unique(ForwardIterator first, ForwardIterator last); 2537a984708SDavid Chisnall 2547a984708SDavid Chisnalltemplate <class ForwardIterator, class BinaryPredicate> 2557a984708SDavid Chisnall ForwardIterator 2567a984708SDavid Chisnall unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 2577a984708SDavid Chisnall 2587a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator> 2597a984708SDavid Chisnall OutputIterator 2607a984708SDavid Chisnall unique_copy(InputIterator first, InputIterator last, OutputIterator result); 2617a984708SDavid Chisnall 2627a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class BinaryPredicate> 2637a984708SDavid Chisnall OutputIterator 2647a984708SDavid Chisnall unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); 2657a984708SDavid Chisnall 2667a984708SDavid Chisnalltemplate <class BidirectionalIterator> 2677a984708SDavid Chisnall void 2687a984708SDavid Chisnall reverse(BidirectionalIterator first, BidirectionalIterator last); 2697a984708SDavid Chisnall 2707a984708SDavid Chisnalltemplate <class BidirectionalIterator, class OutputIterator> 2717a984708SDavid Chisnall OutputIterator 2727a984708SDavid Chisnall reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); 2737a984708SDavid Chisnall 2747a984708SDavid Chisnalltemplate <class ForwardIterator> 2757a984708SDavid Chisnall ForwardIterator 2767a984708SDavid Chisnall rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); 2777a984708SDavid Chisnall 2787a984708SDavid Chisnalltemplate <class ForwardIterator, class OutputIterator> 2797a984708SDavid Chisnall OutputIterator 2807a984708SDavid Chisnall rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); 2817a984708SDavid Chisnall 2827a984708SDavid Chisnalltemplate <class RandomAccessIterator> 2837a984708SDavid Chisnall void 284d72607e9SDimitry Andric random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14 2857a984708SDavid Chisnall 2867a984708SDavid Chisnalltemplate <class RandomAccessIterator, class RandomNumberGenerator> 2877a984708SDavid Chisnall void 288d72607e9SDimitry Andric random_shuffle(RandomAccessIterator first, RandomAccessIterator last, 289d72607e9SDimitry Andric RandomNumberGenerator& rand); // deprecated in C++14 2907a984708SDavid Chisnall 291aed8d94eSDimitry Andrictemplate<class PopulationIterator, class SampleIterator, 292aed8d94eSDimitry Andric class Distance, class UniformRandomBitGenerator> 293aed8d94eSDimitry Andric SampleIterator sample(PopulationIterator first, PopulationIterator last, 294aed8d94eSDimitry Andric SampleIterator out, Distance n, 295aed8d94eSDimitry Andric UniformRandomBitGenerator&& g); // C++17 296aed8d94eSDimitry Andric 2977a984708SDavid Chisnalltemplate<class RandomAccessIterator, class UniformRandomNumberGenerator> 2987a984708SDavid Chisnall void shuffle(RandomAccessIterator first, RandomAccessIterator last, 2997a984708SDavid Chisnall UniformRandomNumberGenerator&& g); 3007a984708SDavid Chisnall 3017a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 3027a984708SDavid Chisnall bool 3037a984708SDavid Chisnall is_partitioned(InputIterator first, InputIterator last, Predicate pred); 3047a984708SDavid Chisnall 3057a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate> 3067a984708SDavid Chisnall ForwardIterator 3077a984708SDavid Chisnall partition(ForwardIterator first, ForwardIterator last, Predicate pred); 3087a984708SDavid Chisnall 3097a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator1, 3107a984708SDavid Chisnall class OutputIterator2, class Predicate> 3117a984708SDavid Chisnall pair<OutputIterator1, OutputIterator2> 3127a984708SDavid Chisnall partition_copy(InputIterator first, InputIterator last, 3137a984708SDavid Chisnall OutputIterator1 out_true, OutputIterator2 out_false, 3147a984708SDavid Chisnall Predicate pred); 3157a984708SDavid Chisnall 3167a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate> 3177a984708SDavid Chisnall ForwardIterator 3187a984708SDavid Chisnall stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred); 3197a984708SDavid Chisnall 3207a984708SDavid Chisnalltemplate<class ForwardIterator, class Predicate> 3217a984708SDavid Chisnall ForwardIterator 3227a984708SDavid Chisnall partition_point(ForwardIterator first, ForwardIterator last, Predicate pred); 3237a984708SDavid Chisnall 3247a984708SDavid Chisnalltemplate <class ForwardIterator> 3257a984708SDavid Chisnall bool 3267a984708SDavid Chisnall is_sorted(ForwardIterator first, ForwardIterator last); 3277a984708SDavid Chisnall 3287a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 3297a984708SDavid Chisnall bool 3307a984708SDavid Chisnall is_sorted(ForwardIterator first, ForwardIterator last, Compare comp); 3317a984708SDavid Chisnall 3327a984708SDavid Chisnalltemplate<class ForwardIterator> 3337a984708SDavid Chisnall ForwardIterator 3347a984708SDavid Chisnall is_sorted_until(ForwardIterator first, ForwardIterator last); 3357a984708SDavid Chisnall 3367a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 3377a984708SDavid Chisnall ForwardIterator 3387a984708SDavid Chisnall is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp); 3397a984708SDavid Chisnall 3407a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3417a984708SDavid Chisnall void 3427a984708SDavid Chisnall sort(RandomAccessIterator first, RandomAccessIterator last); 3437a984708SDavid Chisnall 3447a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3457a984708SDavid Chisnall void 3467a984708SDavid Chisnall sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 3477a984708SDavid Chisnall 3487a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3497a984708SDavid Chisnall void 3507a984708SDavid Chisnall stable_sort(RandomAccessIterator first, RandomAccessIterator last); 3517a984708SDavid Chisnall 3527a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3537a984708SDavid Chisnall void 3547a984708SDavid Chisnall stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 3557a984708SDavid Chisnall 3567a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3577a984708SDavid Chisnall void 3587a984708SDavid Chisnall partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); 3597a984708SDavid Chisnall 3607a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3617a984708SDavid Chisnall void 3627a984708SDavid Chisnall partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); 3637a984708SDavid Chisnall 3647a984708SDavid Chisnalltemplate <class InputIterator, class RandomAccessIterator> 3657a984708SDavid Chisnall RandomAccessIterator 3667a984708SDavid Chisnall partial_sort_copy(InputIterator first, InputIterator last, 3677a984708SDavid Chisnall RandomAccessIterator result_first, RandomAccessIterator result_last); 3687a984708SDavid Chisnall 3697a984708SDavid Chisnalltemplate <class InputIterator, class RandomAccessIterator, class Compare> 3707a984708SDavid Chisnall RandomAccessIterator 3717a984708SDavid Chisnall partial_sort_copy(InputIterator first, InputIterator last, 3727a984708SDavid Chisnall RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); 3737a984708SDavid Chisnall 3747a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3757a984708SDavid Chisnall void 3767a984708SDavid Chisnall nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); 3777a984708SDavid Chisnall 3787a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3797a984708SDavid Chisnall void 3807a984708SDavid Chisnall nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); 3817a984708SDavid Chisnall 3827a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3837a984708SDavid Chisnall ForwardIterator 3847a984708SDavid Chisnall lower_bound(ForwardIterator first, ForwardIterator last, const T& value); 3857a984708SDavid Chisnall 3867a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 3877a984708SDavid Chisnall ForwardIterator 3887a984708SDavid Chisnall lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 3897a984708SDavid Chisnall 3907a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3917a984708SDavid Chisnall ForwardIterator 3927a984708SDavid Chisnall upper_bound(ForwardIterator first, ForwardIterator last, const T& value); 3937a984708SDavid Chisnall 3947a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 3957a984708SDavid Chisnall ForwardIterator 3967a984708SDavid Chisnall upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 3977a984708SDavid Chisnall 3987a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3997a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 4007a984708SDavid Chisnall equal_range(ForwardIterator first, ForwardIterator last, const T& value); 4017a984708SDavid Chisnall 4027a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 4037a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 4047a984708SDavid Chisnall equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 4057a984708SDavid Chisnall 4067a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 4077a984708SDavid Chisnall bool 4087a984708SDavid Chisnall binary_search(ForwardIterator first, ForwardIterator last, const T& value); 4097a984708SDavid Chisnall 4107a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 4117a984708SDavid Chisnall bool 4127a984708SDavid Chisnall binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 4137a984708SDavid Chisnall 4147a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4157a984708SDavid Chisnall OutputIterator 4167a984708SDavid Chisnall merge(InputIterator1 first1, InputIterator1 last1, 4177a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4187a984708SDavid Chisnall 4197a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4207a984708SDavid Chisnall OutputIterator 4217a984708SDavid Chisnall merge(InputIterator1 first1, InputIterator1 last1, 4227a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4237a984708SDavid Chisnall 4247a984708SDavid Chisnalltemplate <class BidirectionalIterator> 4257a984708SDavid Chisnall void 4267a984708SDavid Chisnall inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); 4277a984708SDavid Chisnall 4287a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare> 4297a984708SDavid Chisnall void 4307a984708SDavid Chisnall inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); 4317a984708SDavid Chisnall 4327a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 4337a984708SDavid Chisnall bool 4347a984708SDavid Chisnall includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 4357a984708SDavid Chisnall 4367a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class Compare> 4377a984708SDavid Chisnall bool 4387a984708SDavid Chisnall includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); 4397a984708SDavid Chisnall 4407a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4417a984708SDavid Chisnall OutputIterator 4427a984708SDavid Chisnall set_union(InputIterator1 first1, InputIterator1 last1, 4437a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4447a984708SDavid Chisnall 4457a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4467a984708SDavid Chisnall OutputIterator 4477a984708SDavid Chisnall set_union(InputIterator1 first1, InputIterator1 last1, 4487a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4497a984708SDavid Chisnall 4507a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4517a984708SDavid Chisnall OutputIterator 4527a984708SDavid Chisnall set_intersection(InputIterator1 first1, InputIterator1 last1, 4537a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4547a984708SDavid Chisnall 4557a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4567a984708SDavid Chisnall OutputIterator 4577a984708SDavid Chisnall set_intersection(InputIterator1 first1, InputIterator1 last1, 4587a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4597a984708SDavid Chisnall 4607a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4617a984708SDavid Chisnall OutputIterator 4627a984708SDavid Chisnall set_difference(InputIterator1 first1, InputIterator1 last1, 4637a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4647a984708SDavid Chisnall 4657a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4667a984708SDavid Chisnall OutputIterator 4677a984708SDavid Chisnall set_difference(InputIterator1 first1, InputIterator1 last1, 4687a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4697a984708SDavid Chisnall 4707a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4717a984708SDavid Chisnall OutputIterator 4727a984708SDavid Chisnall set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 4737a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4747a984708SDavid Chisnall 4757a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4767a984708SDavid Chisnall OutputIterator 4777a984708SDavid Chisnall set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 4787a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4797a984708SDavid Chisnall 4807a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4817a984708SDavid Chisnall void 4827a984708SDavid Chisnall push_heap(RandomAccessIterator first, RandomAccessIterator last); 4837a984708SDavid Chisnall 4847a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4857a984708SDavid Chisnall void 4867a984708SDavid Chisnall push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 4877a984708SDavid Chisnall 4887a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4897a984708SDavid Chisnall void 4907a984708SDavid Chisnall pop_heap(RandomAccessIterator first, RandomAccessIterator last); 4917a984708SDavid Chisnall 4927a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4937a984708SDavid Chisnall void 4947a984708SDavid Chisnall pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 4957a984708SDavid Chisnall 4967a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4977a984708SDavid Chisnall void 4987a984708SDavid Chisnall make_heap(RandomAccessIterator first, RandomAccessIterator last); 4997a984708SDavid Chisnall 5007a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 5017a984708SDavid Chisnall void 5027a984708SDavid Chisnall make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 5037a984708SDavid Chisnall 5047a984708SDavid Chisnalltemplate <class RandomAccessIterator> 5057a984708SDavid Chisnall void 5067a984708SDavid Chisnall sort_heap(RandomAccessIterator first, RandomAccessIterator last); 5077a984708SDavid Chisnall 5087a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 5097a984708SDavid Chisnall void 5107a984708SDavid Chisnall sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 5117a984708SDavid Chisnall 5127a984708SDavid Chisnalltemplate <class RandomAccessIterator> 5137a984708SDavid Chisnall bool 5147a984708SDavid Chisnall is_heap(RandomAccessIterator first, RandomAccessiterator last); 5157a984708SDavid Chisnall 5167a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 5177a984708SDavid Chisnall bool 5187a984708SDavid Chisnall is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 5197a984708SDavid Chisnall 5207a984708SDavid Chisnalltemplate <class RandomAccessIterator> 5217a984708SDavid Chisnall RandomAccessIterator 5227a984708SDavid Chisnall is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 5237a984708SDavid Chisnall 5247a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 5257a984708SDavid Chisnall RandomAccessIterator 5267a984708SDavid Chisnall is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 5277a984708SDavid Chisnall 5287a984708SDavid Chisnalltemplate <class ForwardIterator> 5297a984708SDavid Chisnall ForwardIterator 530854fa44bSDimitry Andric min_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14 5317a984708SDavid Chisnall 5327a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 5337a984708SDavid Chisnall ForwardIterator 534854fa44bSDimitry Andric min_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14 5357a984708SDavid Chisnall 5367a984708SDavid Chisnalltemplate <class T> 5377a984708SDavid Chisnall const T& 538d72607e9SDimitry Andric min(const T& a, const T& b); // constexpr in C++14 5397a984708SDavid Chisnall 5407a984708SDavid Chisnalltemplate <class T, class Compare> 5417a984708SDavid Chisnall const T& 542d72607e9SDimitry Andric min(const T& a, const T& b, Compare comp); // constexpr in C++14 5437a984708SDavid Chisnall 5447a984708SDavid Chisnalltemplate<class T> 5457a984708SDavid Chisnall T 546d72607e9SDimitry Andric min(initializer_list<T> t); // constexpr in C++14 5477a984708SDavid Chisnall 5487a984708SDavid Chisnalltemplate<class T, class Compare> 5497a984708SDavid Chisnall T 550d72607e9SDimitry Andric min(initializer_list<T> t, Compare comp); // constexpr in C++14 5517a984708SDavid Chisnall 5527c82a1ecSDimitry Andrictemplate<class T> 5537c82a1ecSDimitry Andric constexpr const T& clamp( const T& v, const T& lo, const T& hi ); // C++17 5547c82a1ecSDimitry Andric 5557c82a1ecSDimitry Andrictemplate<class T, class Compare> 5567c82a1ecSDimitry Andric constexpr const T& clamp( const T& v, const T& lo, const T& hi, Compare comp ); // C++17 5577c82a1ecSDimitry Andric 5587a984708SDavid Chisnalltemplate <class ForwardIterator> 5597a984708SDavid Chisnall ForwardIterator 560854fa44bSDimitry Andric max_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14 5617a984708SDavid Chisnall 5627a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 5637a984708SDavid Chisnall ForwardIterator 564854fa44bSDimitry Andric max_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14 5657a984708SDavid Chisnall 5667a984708SDavid Chisnalltemplate <class T> 5677a984708SDavid Chisnall const T& 568d72607e9SDimitry Andric max(const T& a, const T& b); // constexpr in C++14 5697a984708SDavid Chisnall 5707a984708SDavid Chisnalltemplate <class T, class Compare> 5717a984708SDavid Chisnall const T& 572d72607e9SDimitry Andric max(const T& a, const T& b, Compare comp); // constexpr in C++14 5737a984708SDavid Chisnall 5747a984708SDavid Chisnalltemplate<class T> 5757a984708SDavid Chisnall T 576d72607e9SDimitry Andric max(initializer_list<T> t); // constexpr in C++14 5777a984708SDavid Chisnall 5787a984708SDavid Chisnalltemplate<class T, class Compare> 5797a984708SDavid Chisnall T 580d72607e9SDimitry Andric max(initializer_list<T> t, Compare comp); // constexpr in C++14 5817a984708SDavid Chisnall 5827a984708SDavid Chisnalltemplate<class ForwardIterator> 5837a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 584854fa44bSDimitry Andric minmax_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14 5857a984708SDavid Chisnall 5867a984708SDavid Chisnalltemplate<class ForwardIterator, class Compare> 5877a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 588854fa44bSDimitry Andric minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14 5897a984708SDavid Chisnall 5907a984708SDavid Chisnalltemplate<class T> 5917a984708SDavid Chisnall pair<const T&, const T&> 592d72607e9SDimitry Andric minmax(const T& a, const T& b); // constexpr in C++14 5937a984708SDavid Chisnall 5947a984708SDavid Chisnalltemplate<class T, class Compare> 5957a984708SDavid Chisnall pair<const T&, const T&> 596d72607e9SDimitry Andric minmax(const T& a, const T& b, Compare comp); // constexpr in C++14 5977a984708SDavid Chisnall 5987a984708SDavid Chisnalltemplate<class T> 5997a984708SDavid Chisnall pair<T, T> 600d72607e9SDimitry Andric minmax(initializer_list<T> t); // constexpr in C++14 6017a984708SDavid Chisnall 6027a984708SDavid Chisnalltemplate<class T, class Compare> 6037a984708SDavid Chisnall pair<T, T> 604d72607e9SDimitry Andric minmax(initializer_list<T> t, Compare comp); // constexpr in C++14 6057a984708SDavid Chisnall 6067a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 6077a984708SDavid Chisnall bool 6087a984708SDavid Chisnall lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 6097a984708SDavid Chisnall 6107a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class Compare> 6117a984708SDavid Chisnall bool 6127a984708SDavid Chisnall lexicographical_compare(InputIterator1 first1, InputIterator1 last1, 6137a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, Compare comp); 6147a984708SDavid Chisnall 6157a984708SDavid Chisnalltemplate <class BidirectionalIterator> 6167a984708SDavid Chisnall bool 6177a984708SDavid Chisnall next_permutation(BidirectionalIterator first, BidirectionalIterator last); 6187a984708SDavid Chisnall 6197a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare> 6207a984708SDavid Chisnall bool 6217a984708SDavid Chisnall next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 6227a984708SDavid Chisnall 6237a984708SDavid Chisnalltemplate <class BidirectionalIterator> 6247a984708SDavid Chisnall bool 6257a984708SDavid Chisnall prev_permutation(BidirectionalIterator first, BidirectionalIterator last); 6267a984708SDavid Chisnall 6277a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare> 6287a984708SDavid Chisnall bool 6297a984708SDavid Chisnall prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 6307a984708SDavid Chisnall 6317a984708SDavid Chisnall} // std 6327a984708SDavid Chisnall 6337a984708SDavid Chisnall*/ 6347a984708SDavid Chisnall 6357a984708SDavid Chisnall#include <__config> 6367a984708SDavid Chisnall#include <initializer_list> 6377a984708SDavid Chisnall#include <type_traits> 6387a984708SDavid Chisnall#include <cstring> 6397c82a1ecSDimitry Andric#include <utility> // needed to provide swap_ranges. 6407a984708SDavid Chisnall#include <memory> 6417a984708SDavid Chisnall#include <iterator> 642936e9439SDimitry Andric#include <cstddef> 6437a984708SDavid Chisnall 6444f7ab58eSDimitry Andric#if defined(__IBMCPP__) 6454f7ab58eSDimitry Andric#include "support/ibm/support.h" 6464f7ab58eSDimitry Andric#endif 6474f7ab58eSDimitry Andric#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) 6484f7ab58eSDimitry Andric#include "support/win32/support.h" 6494f7ab58eSDimitry Andric#endif 6504f7ab58eSDimitry Andric 65194e3ee44SDavid Chisnall#include <__undef_min_max> 65294e3ee44SDavid Chisnall 653d72607e9SDimitry Andric#include <__debug> 654d72607e9SDimitry Andric 6557a984708SDavid Chisnall#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 6567a984708SDavid Chisnall#pragma GCC system_header 6577a984708SDavid Chisnall#endif 6587a984708SDavid Chisnall 6597a984708SDavid Chisnall_LIBCPP_BEGIN_NAMESPACE_STD 6607a984708SDavid Chisnall 661d72607e9SDimitry Andric// I'd like to replace these with _VSTD::equal_to<void>, but can't because: 662d72607e9SDimitry Andric// * That only works with C++14 and later, and 663d72607e9SDimitry Andric// * We haven't included <functional> here. 6647a984708SDavid Chisnalltemplate <class _T1, class _T2 = _T1> 6657a984708SDavid Chisnallstruct __equal_to 6667a984708SDavid Chisnall{ 6677a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6687a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;} 6697a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;} 6707a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;} 6717a984708SDavid Chisnall}; 6727a984708SDavid Chisnall 6737a984708SDavid Chisnalltemplate <class _T1> 6747a984708SDavid Chisnallstruct __equal_to<_T1, _T1> 6757a984708SDavid Chisnall{ 676d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 677d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6787a984708SDavid Chisnall}; 6797a984708SDavid Chisnall 6807a984708SDavid Chisnalltemplate <class _T1> 6817a984708SDavid Chisnallstruct __equal_to<const _T1, _T1> 6827a984708SDavid Chisnall{ 683d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 684d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6857a984708SDavid Chisnall}; 6867a984708SDavid Chisnall 6877a984708SDavid Chisnalltemplate <class _T1> 6887a984708SDavid Chisnallstruct __equal_to<_T1, const _T1> 6897a984708SDavid Chisnall{ 690d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 691d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6927a984708SDavid Chisnall}; 6937a984708SDavid Chisnall 6947a984708SDavid Chisnalltemplate <class _T1, class _T2 = _T1> 6957a984708SDavid Chisnallstruct __less 6967a984708SDavid Chisnall{ 697d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 698d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 699d72607e9SDimitry Andric 700d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 701d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;} 702d72607e9SDimitry Andric 703d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 704d72607e9SDimitry Andric bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;} 705d72607e9SDimitry Andric 706d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 707d72607e9SDimitry Andric bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;} 7087a984708SDavid Chisnall}; 7097a984708SDavid Chisnall 7107a984708SDavid Chisnalltemplate <class _T1> 7117a984708SDavid Chisnallstruct __less<_T1, _T1> 7127a984708SDavid Chisnall{ 713d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 714d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 7157a984708SDavid Chisnall}; 7167a984708SDavid Chisnall 7177a984708SDavid Chisnalltemplate <class _T1> 7187a984708SDavid Chisnallstruct __less<const _T1, _T1> 7197a984708SDavid Chisnall{ 720d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 721d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 7227a984708SDavid Chisnall}; 7237a984708SDavid Chisnall 7247a984708SDavid Chisnalltemplate <class _T1> 7257a984708SDavid Chisnallstruct __less<_T1, const _T1> 7267a984708SDavid Chisnall{ 727d72607e9SDimitry Andric _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 728d72607e9SDimitry Andric bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 7297a984708SDavid Chisnall}; 7307a984708SDavid Chisnall 7317a984708SDavid Chisnalltemplate <class _Predicate> 7327a984708SDavid Chisnallclass __negate 7337a984708SDavid Chisnall{ 7347a984708SDavid Chisnallprivate: 7357a984708SDavid Chisnall _Predicate __p_; 7367a984708SDavid Chisnallpublic: 7377a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY __negate() {} 7387a984708SDavid Chisnall 7397a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY 7407a984708SDavid Chisnall explicit __negate(_Predicate __p) : __p_(__p) {} 7417a984708SDavid Chisnall 7427a984708SDavid Chisnall template <class _T1> 7437a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY 7447a984708SDavid Chisnall bool operator()(const _T1& __x) {return !__p_(__x);} 7457a984708SDavid Chisnall 7467a984708SDavid Chisnall template <class _T1, class _T2> 7477a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY 7487a984708SDavid Chisnall bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);} 7497a984708SDavid Chisnall}; 7507a984708SDavid Chisnall 7514f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 7527a984708SDavid Chisnall 7537a984708SDavid Chisnalltemplate <class _Compare> 7547a984708SDavid Chisnallstruct __debug_less 7557a984708SDavid Chisnall{ 7567a984708SDavid Chisnall _Compare __comp_; 7577a984708SDavid Chisnall __debug_less(_Compare& __c) : __comp_(__c) {} 758aed8d94eSDimitry Andric 7597a984708SDavid Chisnall template <class _Tp, class _Up> 7607a984708SDavid Chisnall bool operator()(const _Tp& __x, const _Up& __y) 7617a984708SDavid Chisnall { 7627a984708SDavid Chisnall bool __r = __comp_(__x, __y); 7637a984708SDavid Chisnall if (__r) 764aed8d94eSDimitry Andric __do_compare_assert(0, __y, __x); 7657a984708SDavid Chisnall return __r; 7667a984708SDavid Chisnall } 767aed8d94eSDimitry Andric 768aed8d94eSDimitry Andric template <class _LHS, class _RHS> 769aed8d94eSDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 770aed8d94eSDimitry Andric decltype((void)_VSTD::declval<_Compare&>()( 771aed8d94eSDimitry Andric _VSTD::declval<_LHS const&>(), _VSTD::declval<_RHS const&>())) 772aed8d94eSDimitry Andric __do_compare_assert(int, _LHS const& __l, _RHS const& __r) { 773aed8d94eSDimitry Andric _LIBCPP_ASSERT(!__comp_(__l, __r), 774aed8d94eSDimitry Andric "Comparator does not induce a strict weak ordering"); 775aed8d94eSDimitry Andric } 776aed8d94eSDimitry Andric 777aed8d94eSDimitry Andric template <class _LHS, class _RHS> 778aed8d94eSDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 779aed8d94eSDimitry Andric void __do_compare_assert(long, _LHS const&, _RHS const&) {} 7807a984708SDavid Chisnall}; 7817a984708SDavid Chisnall 7824f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 7837a984708SDavid Chisnall 7847a984708SDavid Chisnall// Precondition: __x != 0 78594e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 78694e3ee44SDavid Chisnallunsigned 78794e3ee44SDavid Chisnall__ctz(unsigned __x) 78894e3ee44SDavid Chisnall{ 78994e3ee44SDavid Chisnall return static_cast<unsigned>(__builtin_ctz(__x)); 79094e3ee44SDavid Chisnall} 79194e3ee44SDavid Chisnall 79294e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 79394e3ee44SDavid Chisnallunsigned long 79494e3ee44SDavid Chisnall__ctz(unsigned long __x) 79594e3ee44SDavid Chisnall{ 79694e3ee44SDavid Chisnall return static_cast<unsigned long>(__builtin_ctzl(__x)); 79794e3ee44SDavid Chisnall} 79894e3ee44SDavid Chisnall 79994e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 80094e3ee44SDavid Chisnallunsigned long long 80194e3ee44SDavid Chisnall__ctz(unsigned long long __x) 80294e3ee44SDavid Chisnall{ 80394e3ee44SDavid Chisnall return static_cast<unsigned long long>(__builtin_ctzll(__x)); 80494e3ee44SDavid Chisnall} 8057a984708SDavid Chisnall 8067a984708SDavid Chisnall// Precondition: __x != 0 80794e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 80894e3ee44SDavid Chisnallunsigned 80994e3ee44SDavid Chisnall__clz(unsigned __x) 81094e3ee44SDavid Chisnall{ 81194e3ee44SDavid Chisnall return static_cast<unsigned>(__builtin_clz(__x)); 81294e3ee44SDavid Chisnall} 81394e3ee44SDavid Chisnall 81494e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 81594e3ee44SDavid Chisnallunsigned long 81694e3ee44SDavid Chisnall__clz(unsigned long __x) 81794e3ee44SDavid Chisnall{ 81894e3ee44SDavid Chisnall return static_cast<unsigned long>(__builtin_clzl (__x)); 81994e3ee44SDavid Chisnall} 82094e3ee44SDavid Chisnall 82194e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 82294e3ee44SDavid Chisnallunsigned long long 82394e3ee44SDavid Chisnall__clz(unsigned long long __x) 82494e3ee44SDavid Chisnall{ 82594e3ee44SDavid Chisnall return static_cast<unsigned long long>(__builtin_clzll(__x)); 82694e3ee44SDavid Chisnall} 8277a984708SDavid Chisnall 8287a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned __x) {return __builtin_popcount (__x);} 8297a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long __x) {return __builtin_popcountl (__x);} 8307a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long long __x) {return __builtin_popcountll(__x);} 8317a984708SDavid Chisnall 8327a984708SDavid Chisnall// all_of 8337a984708SDavid Chisnall 8347a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 8357a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8367a984708SDavid Chisnallbool 8377a984708SDavid Chisnallall_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 8387a984708SDavid Chisnall{ 8397a984708SDavid Chisnall for (; __first != __last; ++__first) 8407a984708SDavid Chisnall if (!__pred(*__first)) 8417a984708SDavid Chisnall return false; 8427a984708SDavid Chisnall return true; 8437a984708SDavid Chisnall} 8447a984708SDavid Chisnall 8457a984708SDavid Chisnall// any_of 8467a984708SDavid Chisnall 8477a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 8487a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8497a984708SDavid Chisnallbool 8507a984708SDavid Chisnallany_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 8517a984708SDavid Chisnall{ 8527a984708SDavid Chisnall for (; __first != __last; ++__first) 8537a984708SDavid Chisnall if (__pred(*__first)) 8547a984708SDavid Chisnall return true; 8557a984708SDavid Chisnall return false; 8567a984708SDavid Chisnall} 8577a984708SDavid Chisnall 8587a984708SDavid Chisnall// none_of 8597a984708SDavid Chisnall 8607a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 8617a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8627a984708SDavid Chisnallbool 8637a984708SDavid Chisnallnone_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 8647a984708SDavid Chisnall{ 8657a984708SDavid Chisnall for (; __first != __last; ++__first) 8667a984708SDavid Chisnall if (__pred(*__first)) 8677a984708SDavid Chisnall return false; 8687a984708SDavid Chisnall return true; 8697a984708SDavid Chisnall} 8707a984708SDavid Chisnall 8717a984708SDavid Chisnall// for_each 8727a984708SDavid Chisnall 8737a984708SDavid Chisnalltemplate <class _InputIterator, class _Function> 8747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8757a984708SDavid Chisnall_Function 8767a984708SDavid Chisnallfor_each(_InputIterator __first, _InputIterator __last, _Function __f) 8777a984708SDavid Chisnall{ 8787a984708SDavid Chisnall for (; __first != __last; ++__first) 8797a984708SDavid Chisnall __f(*__first); 880aed8d94eSDimitry Andric return __f; 8817a984708SDavid Chisnall} 8827a984708SDavid Chisnall 8837a984708SDavid Chisnall// find 8847a984708SDavid Chisnall 8857a984708SDavid Chisnalltemplate <class _InputIterator, class _Tp> 8867a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8877a984708SDavid Chisnall_InputIterator 8887a984708SDavid Chisnallfind(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 8897a984708SDavid Chisnall{ 8907a984708SDavid Chisnall for (; __first != __last; ++__first) 8917a984708SDavid Chisnall if (*__first == __value_) 8927a984708SDavid Chisnall break; 8937a984708SDavid Chisnall return __first; 8947a984708SDavid Chisnall} 8957a984708SDavid Chisnall 8967a984708SDavid Chisnall// find_if 8977a984708SDavid Chisnall 8987a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 8997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 9007a984708SDavid Chisnall_InputIterator 9017a984708SDavid Chisnallfind_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 9027a984708SDavid Chisnall{ 9037a984708SDavid Chisnall for (; __first != __last; ++__first) 9047a984708SDavid Chisnall if (__pred(*__first)) 9057a984708SDavid Chisnall break; 9067a984708SDavid Chisnall return __first; 9077a984708SDavid Chisnall} 9087a984708SDavid Chisnall 9097a984708SDavid Chisnall// find_if_not 9107a984708SDavid Chisnall 9117a984708SDavid Chisnalltemplate<class _InputIterator, class _Predicate> 9127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 9137a984708SDavid Chisnall_InputIterator 9147a984708SDavid Chisnallfind_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) 9157a984708SDavid Chisnall{ 9167a984708SDavid Chisnall for (; __first != __last; ++__first) 9177a984708SDavid Chisnall if (!__pred(*__first)) 9187a984708SDavid Chisnall break; 9197a984708SDavid Chisnall return __first; 9207a984708SDavid Chisnall} 9217a984708SDavid Chisnall 9227a984708SDavid Chisnall// find_end 9237a984708SDavid Chisnall 9247a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 9257a984708SDavid Chisnall_ForwardIterator1 9267a984708SDavid Chisnall__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 9277a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 9287a984708SDavid Chisnall forward_iterator_tag, forward_iterator_tag) 9297a984708SDavid Chisnall{ 9307a984708SDavid Chisnall // modeled after search algorithm 9317a984708SDavid Chisnall _ForwardIterator1 __r = __last1; // __last1 is the "default" answer 9327a984708SDavid Chisnall if (__first2 == __last2) 9337a984708SDavid Chisnall return __r; 9347a984708SDavid Chisnall while (true) 9357a984708SDavid Chisnall { 9367a984708SDavid Chisnall while (true) 9377a984708SDavid Chisnall { 9387a984708SDavid Chisnall if (__first1 == __last1) // if source exhausted return last correct answer 9397a984708SDavid Chisnall return __r; // (or __last1 if never found) 9407a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 9417a984708SDavid Chisnall break; 9427a984708SDavid Chisnall ++__first1; 9437a984708SDavid Chisnall } 9447a984708SDavid Chisnall // *__first1 matches *__first2, now match elements after here 9457a984708SDavid Chisnall _ForwardIterator1 __m1 = __first1; 9467a984708SDavid Chisnall _ForwardIterator2 __m2 = __first2; 9477a984708SDavid Chisnall while (true) 9487a984708SDavid Chisnall { 9497a984708SDavid Chisnall if (++__m2 == __last2) 9507a984708SDavid Chisnall { // Pattern exhaused, record answer and search for another one 9517a984708SDavid Chisnall __r = __first1; 9527a984708SDavid Chisnall ++__first1; 9537a984708SDavid Chisnall break; 9547a984708SDavid Chisnall } 9557a984708SDavid Chisnall if (++__m1 == __last1) // Source exhausted, return last answer 9567a984708SDavid Chisnall return __r; 9577a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) // mismatch, restart with a new __first 9587a984708SDavid Chisnall { 9597a984708SDavid Chisnall ++__first1; 9607a984708SDavid Chisnall break; 9617a984708SDavid Chisnall } // else there is a match, check next elements 9627a984708SDavid Chisnall } 9637a984708SDavid Chisnall } 9647a984708SDavid Chisnall} 9657a984708SDavid Chisnall 9667a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2> 9677a984708SDavid Chisnall_BidirectionalIterator1 9687a984708SDavid Chisnall__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, 9697a984708SDavid Chisnall _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred, 9707a984708SDavid Chisnall bidirectional_iterator_tag, bidirectional_iterator_tag) 9717a984708SDavid Chisnall{ 9727a984708SDavid Chisnall // modeled after search algorithm (in reverse) 9737a984708SDavid Chisnall if (__first2 == __last2) 9747a984708SDavid Chisnall return __last1; // Everything matches an empty sequence 9757a984708SDavid Chisnall _BidirectionalIterator1 __l1 = __last1; 9767a984708SDavid Chisnall _BidirectionalIterator2 __l2 = __last2; 9777a984708SDavid Chisnall --__l2; 9787a984708SDavid Chisnall while (true) 9797a984708SDavid Chisnall { 9807a984708SDavid Chisnall // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks 9817a984708SDavid Chisnall while (true) 9827a984708SDavid Chisnall { 9837a984708SDavid Chisnall if (__first1 == __l1) // return __last1 if no element matches *__first2 9847a984708SDavid Chisnall return __last1; 9857a984708SDavid Chisnall if (__pred(*--__l1, *__l2)) 9867a984708SDavid Chisnall break; 9877a984708SDavid Chisnall } 9887a984708SDavid Chisnall // *__l1 matches *__l2, now match elements before here 9897a984708SDavid Chisnall _BidirectionalIterator1 __m1 = __l1; 9907a984708SDavid Chisnall _BidirectionalIterator2 __m2 = __l2; 9917a984708SDavid Chisnall while (true) 9927a984708SDavid Chisnall { 9937a984708SDavid Chisnall if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern) 9947a984708SDavid Chisnall return __m1; 9957a984708SDavid Chisnall if (__m1 == __first1) // Otherwise if source exhaused, pattern not found 9967a984708SDavid Chisnall return __last1; 9977a984708SDavid Chisnall if (!__pred(*--__m1, *--__m2)) // if there is a mismatch, restart with a new __l1 9987a984708SDavid Chisnall { 9997a984708SDavid Chisnall break; 10007a984708SDavid Chisnall } // else there is a match, check next elements 10017a984708SDavid Chisnall } 10027a984708SDavid Chisnall } 10037a984708SDavid Chisnall} 10047a984708SDavid Chisnall 10057a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1006d72607e9SDimitry Andric_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator1 10077a984708SDavid Chisnall__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 10087a984708SDavid Chisnall _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 10097a984708SDavid Chisnall random_access_iterator_tag, random_access_iterator_tag) 10107a984708SDavid Chisnall{ 10117a984708SDavid Chisnall // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 10127a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2; 10137a984708SDavid Chisnall if (__len2 == 0) 10147a984708SDavid Chisnall return __last1; 10157a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1; 10167a984708SDavid Chisnall if (__len1 < __len2) 10177a984708SDavid Chisnall return __last1; 10187a984708SDavid Chisnall const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here 10197a984708SDavid Chisnall _RandomAccessIterator1 __l1 = __last1; 10207a984708SDavid Chisnall _RandomAccessIterator2 __l2 = __last2; 10217a984708SDavid Chisnall --__l2; 10227a984708SDavid Chisnall while (true) 10237a984708SDavid Chisnall { 10247a984708SDavid Chisnall while (true) 10257a984708SDavid Chisnall { 10267a984708SDavid Chisnall if (__s == __l1) 10277a984708SDavid Chisnall return __last1; 10287a984708SDavid Chisnall if (__pred(*--__l1, *__l2)) 10297a984708SDavid Chisnall break; 10307a984708SDavid Chisnall } 10317a984708SDavid Chisnall _RandomAccessIterator1 __m1 = __l1; 10327a984708SDavid Chisnall _RandomAccessIterator2 __m2 = __l2; 10337a984708SDavid Chisnall while (true) 10347a984708SDavid Chisnall { 10357a984708SDavid Chisnall if (__m2 == __first2) 10367a984708SDavid Chisnall return __m1; 10377a984708SDavid Chisnall // no need to check range on __m1 because __s guarantees we have enough source 10387a984708SDavid Chisnall if (!__pred(*--__m1, *--__m2)) 10397a984708SDavid Chisnall { 10407a984708SDavid Chisnall break; 10417a984708SDavid Chisnall } 10427a984708SDavid Chisnall } 10437a984708SDavid Chisnall } 10447a984708SDavid Chisnall} 10457a984708SDavid Chisnall 10467a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 10477a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10487a984708SDavid Chisnall_ForwardIterator1 10497a984708SDavid Chisnallfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 10507a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 10517a984708SDavid Chisnall{ 10527a984708SDavid Chisnall return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type> 10537a984708SDavid Chisnall (__first1, __last1, __first2, __last2, __pred, 10547a984708SDavid Chisnall typename iterator_traits<_ForwardIterator1>::iterator_category(), 10557a984708SDavid Chisnall typename iterator_traits<_ForwardIterator2>::iterator_category()); 10567a984708SDavid Chisnall} 10577a984708SDavid Chisnall 10587a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2> 10597a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10607a984708SDavid Chisnall_ForwardIterator1 10617a984708SDavid Chisnallfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 10627a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 10637a984708SDavid Chisnall{ 10647a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 10657a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 10667a984708SDavid Chisnall return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 10677a984708SDavid Chisnall} 10687a984708SDavid Chisnall 10697a984708SDavid Chisnall// find_first_of 10707a984708SDavid Chisnall 10717a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1072d72607e9SDimitry Andric_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator1 1073d72607e9SDimitry Andric__find_first_of_ce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 10747a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 10757a984708SDavid Chisnall{ 10767a984708SDavid Chisnall for (; __first1 != __last1; ++__first1) 10777a984708SDavid Chisnall for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 10787a984708SDavid Chisnall if (__pred(*__first1, *__j)) 10797a984708SDavid Chisnall return __first1; 10807a984708SDavid Chisnall return __last1; 10817a984708SDavid Chisnall} 10827a984708SDavid Chisnall 1083d72607e9SDimitry Andric 1084d72607e9SDimitry Andrictemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1085d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 1086d72607e9SDimitry Andric_ForwardIterator1 1087d72607e9SDimitry Andricfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1088d72607e9SDimitry Andric _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1089d72607e9SDimitry Andric{ 1090d72607e9SDimitry Andric return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred); 1091d72607e9SDimitry Andric} 1092d72607e9SDimitry Andric 10937a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2> 10947a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10957a984708SDavid Chisnall_ForwardIterator1 10967a984708SDavid Chisnallfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 10977a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 10987a984708SDavid Chisnall{ 10997a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 11007a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1101d72607e9SDimitry Andric return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 11027a984708SDavid Chisnall} 11037a984708SDavid Chisnall 11047a984708SDavid Chisnall// adjacent_find 11057a984708SDavid Chisnall 11067a984708SDavid Chisnalltemplate <class _ForwardIterator, class _BinaryPredicate> 11077a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11087a984708SDavid Chisnall_ForwardIterator 11097a984708SDavid Chisnalladjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 11107a984708SDavid Chisnall{ 11117a984708SDavid Chisnall if (__first != __last) 11127a984708SDavid Chisnall { 11137a984708SDavid Chisnall _ForwardIterator __i = __first; 11147a984708SDavid Chisnall while (++__i != __last) 11157a984708SDavid Chisnall { 11167a984708SDavid Chisnall if (__pred(*__first, *__i)) 11177a984708SDavid Chisnall return __first; 11187a984708SDavid Chisnall __first = __i; 11197a984708SDavid Chisnall } 11207a984708SDavid Chisnall } 11217a984708SDavid Chisnall return __last; 11227a984708SDavid Chisnall} 11237a984708SDavid Chisnall 11247a984708SDavid Chisnalltemplate <class _ForwardIterator> 11257a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11267a984708SDavid Chisnall_ForwardIterator 11277a984708SDavid Chisnalladjacent_find(_ForwardIterator __first, _ForwardIterator __last) 11287a984708SDavid Chisnall{ 11297a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type __v; 11307a984708SDavid Chisnall return _VSTD::adjacent_find(__first, __last, __equal_to<__v>()); 11317a984708SDavid Chisnall} 11327a984708SDavid Chisnall 11337a984708SDavid Chisnall// count 11347a984708SDavid Chisnall 11357a984708SDavid Chisnalltemplate <class _InputIterator, class _Tp> 11367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11377a984708SDavid Chisnalltypename iterator_traits<_InputIterator>::difference_type 11387a984708SDavid Chisnallcount(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 11397a984708SDavid Chisnall{ 11407a984708SDavid Chisnall typename iterator_traits<_InputIterator>::difference_type __r(0); 11417a984708SDavid Chisnall for (; __first != __last; ++__first) 11427a984708SDavid Chisnall if (*__first == __value_) 11437a984708SDavid Chisnall ++__r; 11447a984708SDavid Chisnall return __r; 11457a984708SDavid Chisnall} 11467a984708SDavid Chisnall 11477a984708SDavid Chisnall// count_if 11487a984708SDavid Chisnall 11497a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 11507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11517a984708SDavid Chisnalltypename iterator_traits<_InputIterator>::difference_type 11527a984708SDavid Chisnallcount_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 11537a984708SDavid Chisnall{ 11547a984708SDavid Chisnall typename iterator_traits<_InputIterator>::difference_type __r(0); 11557a984708SDavid Chisnall for (; __first != __last; ++__first) 11567a984708SDavid Chisnall if (__pred(*__first)) 11577a984708SDavid Chisnall ++__r; 11587a984708SDavid Chisnall return __r; 11597a984708SDavid Chisnall} 11607a984708SDavid Chisnall 11617a984708SDavid Chisnall// mismatch 11627a984708SDavid Chisnall 11637a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 11647a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11657a984708SDavid Chisnallpair<_InputIterator1, _InputIterator2> 11667a984708SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 11677a984708SDavid Chisnall _InputIterator2 __first2, _BinaryPredicate __pred) 11687a984708SDavid Chisnall{ 1169d72607e9SDimitry Andric for (; __first1 != __last1; ++__first1, (void) ++__first2) 11707a984708SDavid Chisnall if (!__pred(*__first1, *__first2)) 11717a984708SDavid Chisnall break; 11727a984708SDavid Chisnall return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 11737a984708SDavid Chisnall} 11747a984708SDavid Chisnall 11757a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 11767a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11777a984708SDavid Chisnallpair<_InputIterator1, _InputIterator2> 11787a984708SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 11797a984708SDavid Chisnall{ 11807a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 11817a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 11827a984708SDavid Chisnall return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 11837a984708SDavid Chisnall} 11847a984708SDavid Chisnall 11854bab9fd9SDavid Chisnall#if _LIBCPP_STD_VER > 11 11864bab9fd9SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 11874bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11884bab9fd9SDavid Chisnallpair<_InputIterator1, _InputIterator2> 11894bab9fd9SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 11904bab9fd9SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, 11914bab9fd9SDavid Chisnall _BinaryPredicate __pred) 11924bab9fd9SDavid Chisnall{ 1193d72607e9SDimitry Andric for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2) 11944bab9fd9SDavid Chisnall if (!__pred(*__first1, *__first2)) 11954bab9fd9SDavid Chisnall break; 11964bab9fd9SDavid Chisnall return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 11974bab9fd9SDavid Chisnall} 11984bab9fd9SDavid Chisnall 11994bab9fd9SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 12004bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12014bab9fd9SDavid Chisnallpair<_InputIterator1, _InputIterator2> 12024bab9fd9SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 12034bab9fd9SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2) 12044bab9fd9SDavid Chisnall{ 12054bab9fd9SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 12064bab9fd9SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 12074bab9fd9SDavid Chisnall return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 12084bab9fd9SDavid Chisnall} 12094bab9fd9SDavid Chisnall#endif 12104bab9fd9SDavid Chisnall 12117a984708SDavid Chisnall// equal 12127a984708SDavid Chisnall 12137a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 12147a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12157a984708SDavid Chisnallbool 12167a984708SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) 12177a984708SDavid Chisnall{ 1218d72607e9SDimitry Andric for (; __first1 != __last1; ++__first1, (void) ++__first2) 12197a984708SDavid Chisnall if (!__pred(*__first1, *__first2)) 12207a984708SDavid Chisnall return false; 12217a984708SDavid Chisnall return true; 12227a984708SDavid Chisnall} 12237a984708SDavid Chisnall 12247a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 12257a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12267a984708SDavid Chisnallbool 12277a984708SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 12287a984708SDavid Chisnall{ 12297a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 12307a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 12317a984708SDavid Chisnall return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 12327a984708SDavid Chisnall} 12337a984708SDavid Chisnall 12344bab9fd9SDavid Chisnall#if _LIBCPP_STD_VER > 11 12354bab9fd9SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator1, class _InputIterator2> 12364bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12374bab9fd9SDavid Chisnallbool 12384bab9fd9SDavid Chisnall__equal(_InputIterator1 __first1, _InputIterator1 __last1, 12394bab9fd9SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred, 12404bab9fd9SDavid Chisnall input_iterator_tag, input_iterator_tag ) 12414bab9fd9SDavid Chisnall{ 1242d72607e9SDimitry Andric for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2) 12434bab9fd9SDavid Chisnall if (!__pred(*__first1, *__first2)) 12444bab9fd9SDavid Chisnall return false; 12454bab9fd9SDavid Chisnall return __first1 == __last1 && __first2 == __last2; 12464bab9fd9SDavid Chisnall} 12474bab9fd9SDavid Chisnall 12484bab9fd9SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 12494bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12504bab9fd9SDavid Chisnallbool 12514bab9fd9SDavid Chisnall__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 12524bab9fd9SDavid Chisnall _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 12534bab9fd9SDavid Chisnall random_access_iterator_tag, random_access_iterator_tag ) 12544bab9fd9SDavid Chisnall{ 12554bab9fd9SDavid Chisnall if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) 12564bab9fd9SDavid Chisnall return false; 12574bab9fd9SDavid Chisnall return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2, 12584bab9fd9SDavid Chisnall typename add_lvalue_reference<_BinaryPredicate>::type> 12594bab9fd9SDavid Chisnall (__first1, __last1, __first2, __pred ); 12604bab9fd9SDavid Chisnall} 12614bab9fd9SDavid Chisnall 12624bab9fd9SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 12634bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12644bab9fd9SDavid Chisnallbool 12654bab9fd9SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, 12664bab9fd9SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred ) 12674bab9fd9SDavid Chisnall{ 12684bab9fd9SDavid Chisnall return _VSTD::__equal<typename add_lvalue_reference<_BinaryPredicate>::type> 12694bab9fd9SDavid Chisnall (__first1, __last1, __first2, __last2, __pred, 12704bab9fd9SDavid Chisnall typename iterator_traits<_InputIterator1>::iterator_category(), 12714bab9fd9SDavid Chisnall typename iterator_traits<_InputIterator2>::iterator_category()); 12724bab9fd9SDavid Chisnall} 12734bab9fd9SDavid Chisnall 12744bab9fd9SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 12754bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 12764bab9fd9SDavid Chisnallbool 12774bab9fd9SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, 12784bab9fd9SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2) 12794bab9fd9SDavid Chisnall{ 12804bab9fd9SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 12814bab9fd9SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 12824bab9fd9SDavid Chisnall return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), 12834bab9fd9SDavid Chisnall typename iterator_traits<_InputIterator1>::iterator_category(), 12844bab9fd9SDavid Chisnall typename iterator_traits<_InputIterator2>::iterator_category()); 12854bab9fd9SDavid Chisnall} 12864bab9fd9SDavid Chisnall#endif 12874bab9fd9SDavid Chisnall 12887a984708SDavid Chisnall// is_permutation 12897a984708SDavid Chisnall 12907a984708SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 12917a984708SDavid Chisnallbool 12927a984708SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 12937a984708SDavid Chisnall _ForwardIterator2 __first2, _BinaryPredicate __pred) 12947a984708SDavid Chisnall{ 12957a984708SDavid Chisnall // shorten sequences as much as possible by lopping of any equal parts 1296d72607e9SDimitry Andric for (; __first1 != __last1; ++__first1, (void) ++__first2) 12977a984708SDavid Chisnall if (!__pred(*__first1, *__first2)) 12987a984708SDavid Chisnall goto __not_done; 12997a984708SDavid Chisnall return true; 13007a984708SDavid Chisnall__not_done: 13017a984708SDavid Chisnall // __first1 != __last1 && *__first1 != *__first2 13027a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 13037a984708SDavid Chisnall _D1 __l1 = _VSTD::distance(__first1, __last1); 13047a984708SDavid Chisnall if (__l1 == _D1(1)) 13057a984708SDavid Chisnall return false; 13067a984708SDavid Chisnall _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1); 13077a984708SDavid Chisnall // For each element in [f1, l1) see if there are the same number of 13087a984708SDavid Chisnall // equal elements in [f2, l2) 13097a984708SDavid Chisnall for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 13107a984708SDavid Chisnall { 13117a984708SDavid Chisnall // Have we already counted the number of *__i in [f1, l1)? 13127a984708SDavid Chisnall for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 13137a984708SDavid Chisnall if (__pred(*__j, *__i)) 13147a984708SDavid Chisnall goto __next_iter; 13157a984708SDavid Chisnall { 13167a984708SDavid Chisnall // Count number of *__i in [f2, l2) 13177a984708SDavid Chisnall _D1 __c2 = 0; 13187a984708SDavid Chisnall for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 13197a984708SDavid Chisnall if (__pred(*__i, *__j)) 13207a984708SDavid Chisnall ++__c2; 13217a984708SDavid Chisnall if (__c2 == 0) 13227a984708SDavid Chisnall return false; 13237a984708SDavid Chisnall // Count number of *__i in [__i, l1) (we can start with 1) 13247a984708SDavid Chisnall _D1 __c1 = 1; 13257a984708SDavid Chisnall for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 13267a984708SDavid Chisnall if (__pred(*__i, *__j)) 13277a984708SDavid Chisnall ++__c1; 13287a984708SDavid Chisnall if (__c1 != __c2) 13297a984708SDavid Chisnall return false; 13307a984708SDavid Chisnall } 13317a984708SDavid Chisnall__next_iter:; 13327a984708SDavid Chisnall } 13337a984708SDavid Chisnall return true; 13347a984708SDavid Chisnall} 13357a984708SDavid Chisnall 13367a984708SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2> 13377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 13387a984708SDavid Chisnallbool 13397a984708SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 13407a984708SDavid Chisnall _ForwardIterator2 __first2) 13417a984708SDavid Chisnall{ 13427a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 13437a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 13447a984708SDavid Chisnall return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 13457a984708SDavid Chisnall} 13467a984708SDavid Chisnall 13474bab9fd9SDavid Chisnall#if _LIBCPP_STD_VER > 11 13484bab9fd9SDavid Chisnalltemplate<class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 13494bab9fd9SDavid Chisnallbool 13504bab9fd9SDavid Chisnall__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 13514bab9fd9SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, 13524bab9fd9SDavid Chisnall _BinaryPredicate __pred, 13534bab9fd9SDavid Chisnall forward_iterator_tag, forward_iterator_tag ) 13544bab9fd9SDavid Chisnall{ 13554bab9fd9SDavid Chisnall // shorten sequences as much as possible by lopping of any equal parts 1356d72607e9SDimitry Andric for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2) 13574bab9fd9SDavid Chisnall if (!__pred(*__first1, *__first2)) 13584bab9fd9SDavid Chisnall goto __not_done; 13594bab9fd9SDavid Chisnall return __first1 == __last1 && __first2 == __last2; 13604bab9fd9SDavid Chisnall__not_done: 13614bab9fd9SDavid Chisnall // __first1 != __last1 && __first2 != __last2 && *__first1 != *__first2 13624bab9fd9SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 13634bab9fd9SDavid Chisnall _D1 __l1 = _VSTD::distance(__first1, __last1); 13644bab9fd9SDavid Chisnall 13654bab9fd9SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2; 13664bab9fd9SDavid Chisnall _D2 __l2 = _VSTD::distance(__first2, __last2); 13674bab9fd9SDavid Chisnall if (__l1 != __l2) 13684bab9fd9SDavid Chisnall return false; 13694bab9fd9SDavid Chisnall 13704bab9fd9SDavid Chisnall // For each element in [f1, l1) see if there are the same number of 13714bab9fd9SDavid Chisnall // equal elements in [f2, l2) 13724bab9fd9SDavid Chisnall for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 13734bab9fd9SDavid Chisnall { 13744bab9fd9SDavid Chisnall // Have we already counted the number of *__i in [f1, l1)? 13754bab9fd9SDavid Chisnall for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 13764bab9fd9SDavid Chisnall if (__pred(*__j, *__i)) 13774bab9fd9SDavid Chisnall goto __next_iter; 13784bab9fd9SDavid Chisnall { 13794bab9fd9SDavid Chisnall // Count number of *__i in [f2, l2) 13804bab9fd9SDavid Chisnall _D1 __c2 = 0; 13814bab9fd9SDavid Chisnall for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 13824bab9fd9SDavid Chisnall if (__pred(*__i, *__j)) 13834bab9fd9SDavid Chisnall ++__c2; 13844bab9fd9SDavid Chisnall if (__c2 == 0) 13854bab9fd9SDavid Chisnall return false; 13864bab9fd9SDavid Chisnall // Count number of *__i in [__i, l1) (we can start with 1) 13874bab9fd9SDavid Chisnall _D1 __c1 = 1; 13884bab9fd9SDavid Chisnall for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 13894bab9fd9SDavid Chisnall if (__pred(*__i, *__j)) 13904bab9fd9SDavid Chisnall ++__c1; 13914bab9fd9SDavid Chisnall if (__c1 != __c2) 13924bab9fd9SDavid Chisnall return false; 13934bab9fd9SDavid Chisnall } 13944bab9fd9SDavid Chisnall__next_iter:; 13954bab9fd9SDavid Chisnall } 13964bab9fd9SDavid Chisnall return true; 13974bab9fd9SDavid Chisnall} 13984bab9fd9SDavid Chisnall 13994bab9fd9SDavid Chisnalltemplate<class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 14004bab9fd9SDavid Chisnallbool 14014bab9fd9SDavid Chisnall__is_permutation(_RandomAccessIterator1 __first1, _RandomAccessIterator2 __last1, 14024bab9fd9SDavid Chisnall _RandomAccessIterator1 __first2, _RandomAccessIterator2 __last2, 14034bab9fd9SDavid Chisnall _BinaryPredicate __pred, 14044bab9fd9SDavid Chisnall random_access_iterator_tag, random_access_iterator_tag ) 14054bab9fd9SDavid Chisnall{ 14064bab9fd9SDavid Chisnall if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) 14074bab9fd9SDavid Chisnall return false; 14084bab9fd9SDavid Chisnall return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2, 14094bab9fd9SDavid Chisnall typename add_lvalue_reference<_BinaryPredicate>::type> 14104bab9fd9SDavid Chisnall (__first1, __last1, __first2, __pred ); 14114bab9fd9SDavid Chisnall} 14124bab9fd9SDavid Chisnall 14134bab9fd9SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 14144bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14154bab9fd9SDavid Chisnallbool 14164bab9fd9SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 14174bab9fd9SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, 14184bab9fd9SDavid Chisnall _BinaryPredicate __pred ) 14194bab9fd9SDavid Chisnall{ 14204bab9fd9SDavid Chisnall return _VSTD::__is_permutation<typename add_lvalue_reference<_BinaryPredicate>::type> 14214bab9fd9SDavid Chisnall (__first1, __last1, __first2, __last2, __pred, 14224bab9fd9SDavid Chisnall typename iterator_traits<_ForwardIterator1>::iterator_category(), 14234bab9fd9SDavid Chisnall typename iterator_traits<_ForwardIterator2>::iterator_category()); 14244bab9fd9SDavid Chisnall} 14254bab9fd9SDavid Chisnall 14264bab9fd9SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2> 14274bab9fd9SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14284bab9fd9SDavid Chisnallbool 14294bab9fd9SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 14304bab9fd9SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 14314bab9fd9SDavid Chisnall{ 14324bab9fd9SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 14334bab9fd9SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 14344bab9fd9SDavid Chisnall return _VSTD::__is_permutation(__first1, __last1, __first2, __last2, 14354bab9fd9SDavid Chisnall __equal_to<__v1, __v2>(), 14364bab9fd9SDavid Chisnall typename iterator_traits<_ForwardIterator1>::iterator_category(), 14374bab9fd9SDavid Chisnall typename iterator_traits<_ForwardIterator2>::iterator_category()); 14384bab9fd9SDavid Chisnall} 14394bab9fd9SDavid Chisnall#endif 14404bab9fd9SDavid Chisnall 14417a984708SDavid Chisnall// search 14427a984708SDavid Chisnall 14437a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 14447c82a1ecSDimitry Andricpair<_ForwardIterator1, _ForwardIterator1> 14457a984708SDavid Chisnall__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 14467a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 14477a984708SDavid Chisnall forward_iterator_tag, forward_iterator_tag) 14487a984708SDavid Chisnall{ 14497a984708SDavid Chisnall if (__first2 == __last2) 14507c82a1ecSDimitry Andric return make_pair(__first1, __first1); // Everything matches an empty sequence 14517a984708SDavid Chisnall while (true) 14527a984708SDavid Chisnall { 14537a984708SDavid Chisnall // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks 14547a984708SDavid Chisnall while (true) 14557a984708SDavid Chisnall { 14567a984708SDavid Chisnall if (__first1 == __last1) // return __last1 if no element matches *__first2 14577c82a1ecSDimitry Andric return make_pair(__last1, __last1); 14587a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 14597a984708SDavid Chisnall break; 14607a984708SDavid Chisnall ++__first1; 14617a984708SDavid Chisnall } 14627a984708SDavid Chisnall // *__first1 matches *__first2, now match elements after here 14637a984708SDavid Chisnall _ForwardIterator1 __m1 = __first1; 14647a984708SDavid Chisnall _ForwardIterator2 __m2 = __first2; 14657a984708SDavid Chisnall while (true) 14667a984708SDavid Chisnall { 14677a984708SDavid Chisnall if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern) 14687c82a1ecSDimitry Andric return make_pair(__first1, __m1); 14697a984708SDavid Chisnall if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found 14707c82a1ecSDimitry Andric return make_pair(__last1, __last1); 14717a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1 14727a984708SDavid Chisnall { 14737a984708SDavid Chisnall ++__first1; 14747a984708SDavid Chisnall break; 14757a984708SDavid Chisnall } // else there is a match, check next elements 14767a984708SDavid Chisnall } 14777a984708SDavid Chisnall } 14787a984708SDavid Chisnall} 14797a984708SDavid Chisnall 14807a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 14817c82a1ecSDimitry Andric_LIBCPP_CONSTEXPR_AFTER_CXX11 14827c82a1ecSDimitry Andricpair<_RandomAccessIterator1, _RandomAccessIterator1> 14837a984708SDavid Chisnall__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 14847a984708SDavid Chisnall _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 14857a984708SDavid Chisnall random_access_iterator_tag, random_access_iterator_tag) 14867a984708SDavid Chisnall{ 14877c82a1ecSDimitry Andric typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1; 14887c82a1ecSDimitry Andric typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2; 14897a984708SDavid Chisnall // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 14907c82a1ecSDimitry Andric const _D2 __len2 = __last2 - __first2; 14917a984708SDavid Chisnall if (__len2 == 0) 14927c82a1ecSDimitry Andric return make_pair(__first1, __first1); 14937c82a1ecSDimitry Andric const _D1 __len1 = __last1 - __first1; 14947a984708SDavid Chisnall if (__len1 < __len2) 14957c82a1ecSDimitry Andric return make_pair(__last1, __last1); 14967a984708SDavid Chisnall const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here 1497aed8d94eSDimitry Andric 14987a984708SDavid Chisnall while (true) 14997a984708SDavid Chisnall { 15007a984708SDavid Chisnall while (true) 15017a984708SDavid Chisnall { 15027a984708SDavid Chisnall if (__first1 == __s) 15037c82a1ecSDimitry Andric return make_pair(__last1, __last1); 15047a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 15057a984708SDavid Chisnall break; 15067a984708SDavid Chisnall ++__first1; 15077a984708SDavid Chisnall } 1508aed8d94eSDimitry Andric 15097a984708SDavid Chisnall _RandomAccessIterator1 __m1 = __first1; 15107a984708SDavid Chisnall _RandomAccessIterator2 __m2 = __first2; 15117a984708SDavid Chisnall while (true) 15127a984708SDavid Chisnall { 15137a984708SDavid Chisnall if (++__m2 == __last2) 15147c82a1ecSDimitry Andric return make_pair(__first1, __first1 + __len2); 15157a984708SDavid Chisnall ++__m1; // no need to check range on __m1 because __s guarantees we have enough source 15167a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) 15177a984708SDavid Chisnall { 15187a984708SDavid Chisnall ++__first1; 15197a984708SDavid Chisnall break; 15207a984708SDavid Chisnall } 15217a984708SDavid Chisnall } 15227a984708SDavid Chisnall } 15237a984708SDavid Chisnall} 15247a984708SDavid Chisnall 15257a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 15267a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15277a984708SDavid Chisnall_ForwardIterator1 15287a984708SDavid Chisnallsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 15297a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 15307a984708SDavid Chisnall{ 15317a984708SDavid Chisnall return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type> 15327a984708SDavid Chisnall (__first1, __last1, __first2, __last2, __pred, 15337c82a1ecSDimitry Andric typename iterator_traits<_ForwardIterator1>::iterator_category(), 15347c82a1ecSDimitry Andric typename iterator_traits<_ForwardIterator2>::iterator_category()) 15357c82a1ecSDimitry Andric .first; 15367a984708SDavid Chisnall} 15377a984708SDavid Chisnall 15387a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2> 15397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15407a984708SDavid Chisnall_ForwardIterator1 15417a984708SDavid Chisnallsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 15427a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 15437a984708SDavid Chisnall{ 15447c82a1ecSDimitry Andric typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 15457c82a1ecSDimitry Andric typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 15467a984708SDavid Chisnall return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 15477a984708SDavid Chisnall} 15487a984708SDavid Chisnall 15497a984708SDavid Chisnall// search_n 15507a984708SDavid Chisnall 15517a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp> 15527a984708SDavid Chisnall_ForwardIterator 15537a984708SDavid Chisnall__search_n(_ForwardIterator __first, _ForwardIterator __last, 15547a984708SDavid Chisnall _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag) 15557a984708SDavid Chisnall{ 15567a984708SDavid Chisnall if (__count <= 0) 15577a984708SDavid Chisnall return __first; 15587a984708SDavid Chisnall while (true) 15597a984708SDavid Chisnall { 15607a984708SDavid Chisnall // Find first element in sequence that matchs __value_, with a mininum of loop checks 15617a984708SDavid Chisnall while (true) 15627a984708SDavid Chisnall { 15637a984708SDavid Chisnall if (__first == __last) // return __last if no element matches __value_ 15647a984708SDavid Chisnall return __last; 15657a984708SDavid Chisnall if (__pred(*__first, __value_)) 15667a984708SDavid Chisnall break; 15677a984708SDavid Chisnall ++__first; 15687a984708SDavid Chisnall } 15697a984708SDavid Chisnall // *__first matches __value_, now match elements after here 15707a984708SDavid Chisnall _ForwardIterator __m = __first; 15717a984708SDavid Chisnall _Size __c(0); 15727a984708SDavid Chisnall while (true) 15737a984708SDavid Chisnall { 15747a984708SDavid Chisnall if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 15757a984708SDavid Chisnall return __first; 15767a984708SDavid Chisnall if (++__m == __last) // Otherwise if source exhaused, pattern not found 15777a984708SDavid Chisnall return __last; 15787a984708SDavid Chisnall if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 15797a984708SDavid Chisnall { 15807a984708SDavid Chisnall __first = __m; 15817a984708SDavid Chisnall ++__first; 15827a984708SDavid Chisnall break; 15837a984708SDavid Chisnall } // else there is a match, check next elements 15847a984708SDavid Chisnall } 15857a984708SDavid Chisnall } 15867a984708SDavid Chisnall} 15877a984708SDavid Chisnall 15887a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp> 15897a984708SDavid Chisnall_RandomAccessIterator 15907a984708SDavid Chisnall__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last, 15917a984708SDavid Chisnall _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag) 15927a984708SDavid Chisnall{ 15937a984708SDavid Chisnall if (__count <= 0) 15947a984708SDavid Chisnall return __first; 15957a984708SDavid Chisnall _Size __len = static_cast<_Size>(__last - __first); 15967a984708SDavid Chisnall if (__len < __count) 15977a984708SDavid Chisnall return __last; 15987a984708SDavid Chisnall const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here 15997a984708SDavid Chisnall while (true) 16007a984708SDavid Chisnall { 16017a984708SDavid Chisnall // Find first element in sequence that matchs __value_, with a mininum of loop checks 16027a984708SDavid Chisnall while (true) 16037a984708SDavid Chisnall { 16041bf9f7c1SDimitry Andric if (__first >= __s) // return __last if no element matches __value_ 16057a984708SDavid Chisnall return __last; 16067a984708SDavid Chisnall if (__pred(*__first, __value_)) 16077a984708SDavid Chisnall break; 16087a984708SDavid Chisnall ++__first; 16097a984708SDavid Chisnall } 16107a984708SDavid Chisnall // *__first matches __value_, now match elements after here 16117a984708SDavid Chisnall _RandomAccessIterator __m = __first; 16127a984708SDavid Chisnall _Size __c(0); 16137a984708SDavid Chisnall while (true) 16147a984708SDavid Chisnall { 16157a984708SDavid Chisnall if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 16167a984708SDavid Chisnall return __first; 16177a984708SDavid Chisnall ++__m; // no need to check range on __m because __s guarantees we have enough source 16187a984708SDavid Chisnall if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 16197a984708SDavid Chisnall { 16207a984708SDavid Chisnall __first = __m; 16217a984708SDavid Chisnall ++__first; 16227a984708SDavid Chisnall break; 16237a984708SDavid Chisnall } // else there is a match, check next elements 16247a984708SDavid Chisnall } 16257a984708SDavid Chisnall } 16267a984708SDavid Chisnall} 16277a984708SDavid Chisnall 16287a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> 16297a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16307a984708SDavid Chisnall_ForwardIterator 16317a984708SDavid Chisnallsearch_n(_ForwardIterator __first, _ForwardIterator __last, 16327a984708SDavid Chisnall _Size __count, const _Tp& __value_, _BinaryPredicate __pred) 16337a984708SDavid Chisnall{ 16347a984708SDavid Chisnall return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type> 1635854fa44bSDimitry Andric (__first, __last, __convert_to_integral(__count), __value_, __pred, 1636854fa44bSDimitry Andric typename iterator_traits<_ForwardIterator>::iterator_category()); 16377a984708SDavid Chisnall} 16387a984708SDavid Chisnall 16397a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Size, class _Tp> 16407a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16417a984708SDavid Chisnall_ForwardIterator 16427a984708SDavid Chisnallsearch_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) 16437a984708SDavid Chisnall{ 16447a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type __v; 1645854fa44bSDimitry Andric return _VSTD::search_n(__first, __last, __convert_to_integral(__count), 1646854fa44bSDimitry Andric __value_, __equal_to<__v, _Tp>()); 16477a984708SDavid Chisnall} 16487a984708SDavid Chisnall 16497a984708SDavid Chisnall// copy 16507a984708SDavid Chisnalltemplate <class _Iter> 16517a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16527a984708SDavid Chisnall_Iter 16537a984708SDavid Chisnall__unwrap_iter(_Iter __i) 16547a984708SDavid Chisnall{ 16557a984708SDavid Chisnall return __i; 16567a984708SDavid Chisnall} 16577a984708SDavid Chisnall 16587a984708SDavid Chisnalltemplate <class _Tp> 16597a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16607a984708SDavid Chisnalltypename enable_if 16617a984708SDavid Chisnall< 16627a984708SDavid Chisnall is_trivially_copy_assignable<_Tp>::value, 16637a984708SDavid Chisnall _Tp* 16647a984708SDavid Chisnall>::type 16657a984708SDavid Chisnall__unwrap_iter(move_iterator<_Tp*> __i) 16667a984708SDavid Chisnall{ 16677a984708SDavid Chisnall return __i.base(); 16687a984708SDavid Chisnall} 16697a984708SDavid Chisnall 16704f7ab58eSDimitry Andric#if _LIBCPP_DEBUG_LEVEL < 2 16714f7ab58eSDimitry Andric 16727a984708SDavid Chisnalltemplate <class _Tp> 16737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16747a984708SDavid Chisnalltypename enable_if 16757a984708SDavid Chisnall< 16767a984708SDavid Chisnall is_trivially_copy_assignable<_Tp>::value, 16777a984708SDavid Chisnall _Tp* 16787a984708SDavid Chisnall>::type 16797a984708SDavid Chisnall__unwrap_iter(__wrap_iter<_Tp*> __i) 16807a984708SDavid Chisnall{ 16817a984708SDavid Chisnall return __i.base(); 16827a984708SDavid Chisnall} 16837a984708SDavid Chisnall 1684aed8d94eSDimitry Andric#else 1685aed8d94eSDimitry Andric 1686aed8d94eSDimitry Andrictemplate <class _Tp> 1687aed8d94eSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 1688aed8d94eSDimitry Andrictypename enable_if 1689aed8d94eSDimitry Andric< 1690aed8d94eSDimitry Andric is_trivially_copy_assignable<_Tp>::value, 1691aed8d94eSDimitry Andric __wrap_iter<_Tp*> 1692aed8d94eSDimitry Andric>::type 1693aed8d94eSDimitry Andric__unwrap_iter(__wrap_iter<_Tp*> __i) 1694aed8d94eSDimitry Andric{ 1695aed8d94eSDimitry Andric return __i; 1696aed8d94eSDimitry Andric} 1697aed8d94eSDimitry Andric 16984f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG_LEVEL < 2 16994f7ab58eSDimitry Andric 17007a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 17017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17027a984708SDavid Chisnall_OutputIterator 17037a984708SDavid Chisnall__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 17047a984708SDavid Chisnall{ 1705d72607e9SDimitry Andric for (; __first != __last; ++__first, (void) ++__result) 17067a984708SDavid Chisnall *__result = *__first; 17077a984708SDavid Chisnall return __result; 17087a984708SDavid Chisnall} 17097a984708SDavid Chisnall 17107a984708SDavid Chisnalltemplate <class _Tp, class _Up> 17117a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17127a984708SDavid Chisnalltypename enable_if 17137a984708SDavid Chisnall< 17147a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 17157a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 17167a984708SDavid Chisnall _Up* 17177a984708SDavid Chisnall>::type 17187a984708SDavid Chisnall__copy(_Tp* __first, _Tp* __last, _Up* __result) 17197a984708SDavid Chisnall{ 17207a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 1721854fa44bSDimitry Andric if (__n > 0) 17227a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 17237a984708SDavid Chisnall return __result + __n; 17247a984708SDavid Chisnall} 17257a984708SDavid Chisnall 17267a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 17277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17287a984708SDavid Chisnall_OutputIterator 17297a984708SDavid Chisnallcopy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 17307a984708SDavid Chisnall{ 17317a984708SDavid Chisnall return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 17327a984708SDavid Chisnall} 17337a984708SDavid Chisnall 17347a984708SDavid Chisnall// copy_backward 17357a984708SDavid Chisnall 1736cfdf2879SDavid Chisnalltemplate <class _BidirectionalIterator, class _OutputIterator> 17377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17387a984708SDavid Chisnall_OutputIterator 1739cfdf2879SDavid Chisnall__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 17407a984708SDavid Chisnall{ 17417a984708SDavid Chisnall while (__first != __last) 17427a984708SDavid Chisnall *--__result = *--__last; 17437a984708SDavid Chisnall return __result; 17447a984708SDavid Chisnall} 17457a984708SDavid Chisnall 17467a984708SDavid Chisnalltemplate <class _Tp, class _Up> 17477a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17487a984708SDavid Chisnalltypename enable_if 17497a984708SDavid Chisnall< 17507a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 17517a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 17527a984708SDavid Chisnall _Up* 17537a984708SDavid Chisnall>::type 17547a984708SDavid Chisnall__copy_backward(_Tp* __first, _Tp* __last, _Up* __result) 17557a984708SDavid Chisnall{ 17567a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 1757854fa44bSDimitry Andric if (__n > 0) 1758854fa44bSDimitry Andric { 17597a984708SDavid Chisnall __result -= __n; 17607a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1761854fa44bSDimitry Andric } 17627a984708SDavid Chisnall return __result; 17637a984708SDavid Chisnall} 17647a984708SDavid Chisnall 17657a984708SDavid Chisnalltemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 17667a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17677a984708SDavid Chisnall_BidirectionalIterator2 17687a984708SDavid Chisnallcopy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 17697a984708SDavid Chisnall _BidirectionalIterator2 __result) 17707a984708SDavid Chisnall{ 1771aed8d94eSDimitry Andric return _VSTD::__copy_backward(__unwrap_iter(__first), 1772aed8d94eSDimitry Andric __unwrap_iter(__last), 1773aed8d94eSDimitry Andric __unwrap_iter(__result)); 17747a984708SDavid Chisnall} 17757a984708SDavid Chisnall 17767a984708SDavid Chisnall// copy_if 17777a984708SDavid Chisnall 17787a984708SDavid Chisnalltemplate<class _InputIterator, class _OutputIterator, class _Predicate> 17797a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17807a984708SDavid Chisnall_OutputIterator 17817a984708SDavid Chisnallcopy_if(_InputIterator __first, _InputIterator __last, 17827a984708SDavid Chisnall _OutputIterator __result, _Predicate __pred) 17837a984708SDavid Chisnall{ 17847a984708SDavid Chisnall for (; __first != __last; ++__first) 17857a984708SDavid Chisnall { 17867a984708SDavid Chisnall if (__pred(*__first)) 17877a984708SDavid Chisnall { 17887a984708SDavid Chisnall *__result = *__first; 17897a984708SDavid Chisnall ++__result; 17907a984708SDavid Chisnall } 17917a984708SDavid Chisnall } 17927a984708SDavid Chisnall return __result; 17937a984708SDavid Chisnall} 17947a984708SDavid Chisnall 17957a984708SDavid Chisnall// copy_n 17967a984708SDavid Chisnall 17977a984708SDavid Chisnalltemplate<class _InputIterator, class _Size, class _OutputIterator> 17987a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17997a984708SDavid Chisnalltypename enable_if 18007a984708SDavid Chisnall< 18017a984708SDavid Chisnall __is_input_iterator<_InputIterator>::value && 18027a984708SDavid Chisnall !__is_random_access_iterator<_InputIterator>::value, 18037a984708SDavid Chisnall _OutputIterator 18047a984708SDavid Chisnall>::type 1805854fa44bSDimitry Andriccopy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) 18067a984708SDavid Chisnall{ 1807854fa44bSDimitry Andric typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; 1808854fa44bSDimitry Andric _IntegralSize __n = __orig_n; 18097a984708SDavid Chisnall if (__n > 0) 18107a984708SDavid Chisnall { 18117a984708SDavid Chisnall *__result = *__first; 18127a984708SDavid Chisnall ++__result; 18137a984708SDavid Chisnall for (--__n; __n > 0; --__n) 18147a984708SDavid Chisnall { 18157a984708SDavid Chisnall ++__first; 18167a984708SDavid Chisnall *__result = *__first; 18177a984708SDavid Chisnall ++__result; 18187a984708SDavid Chisnall } 18197a984708SDavid Chisnall } 18207a984708SDavid Chisnall return __result; 18217a984708SDavid Chisnall} 18227a984708SDavid Chisnall 18237a984708SDavid Chisnalltemplate<class _InputIterator, class _Size, class _OutputIterator> 18247a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18257a984708SDavid Chisnalltypename enable_if 18267a984708SDavid Chisnall< 18277a984708SDavid Chisnall __is_random_access_iterator<_InputIterator>::value, 18287a984708SDavid Chisnall _OutputIterator 18297a984708SDavid Chisnall>::type 1830854fa44bSDimitry Andriccopy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) 18317a984708SDavid Chisnall{ 1832854fa44bSDimitry Andric typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; 1833854fa44bSDimitry Andric _IntegralSize __n = __orig_n; 18347a984708SDavid Chisnall return _VSTD::copy(__first, __first + __n, __result); 18357a984708SDavid Chisnall} 18367a984708SDavid Chisnall 18377a984708SDavid Chisnall// move 18387a984708SDavid Chisnall 18397a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 18407a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18417a984708SDavid Chisnall_OutputIterator 18427a984708SDavid Chisnall__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 18437a984708SDavid Chisnall{ 1844d72607e9SDimitry Andric for (; __first != __last; ++__first, (void) ++__result) 18457a984708SDavid Chisnall *__result = _VSTD::move(*__first); 18467a984708SDavid Chisnall return __result; 18477a984708SDavid Chisnall} 18487a984708SDavid Chisnall 18497a984708SDavid Chisnalltemplate <class _Tp, class _Up> 18507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18517a984708SDavid Chisnalltypename enable_if 18527a984708SDavid Chisnall< 18537a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 18547a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 18557a984708SDavid Chisnall _Up* 18567a984708SDavid Chisnall>::type 18577a984708SDavid Chisnall__move(_Tp* __first, _Tp* __last, _Up* __result) 18587a984708SDavid Chisnall{ 18597a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 1860854fa44bSDimitry Andric if (__n > 0) 18617a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 18627a984708SDavid Chisnall return __result + __n; 18637a984708SDavid Chisnall} 18647a984708SDavid Chisnall 18657a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 18667a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18677a984708SDavid Chisnall_OutputIterator 18687a984708SDavid Chisnallmove(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 18697a984708SDavid Chisnall{ 18707a984708SDavid Chisnall return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 18717a984708SDavid Chisnall} 18727a984708SDavid Chisnall 18737a984708SDavid Chisnall// move_backward 18747a984708SDavid Chisnall 18757a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 18767a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18777a984708SDavid Chisnall_OutputIterator 18787a984708SDavid Chisnall__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 18797a984708SDavid Chisnall{ 18807a984708SDavid Chisnall while (__first != __last) 18817a984708SDavid Chisnall *--__result = _VSTD::move(*--__last); 18827a984708SDavid Chisnall return __result; 18837a984708SDavid Chisnall} 18847a984708SDavid Chisnall 18857a984708SDavid Chisnalltemplate <class _Tp, class _Up> 18867a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18877a984708SDavid Chisnalltypename enable_if 18887a984708SDavid Chisnall< 18897a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 18907a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 18917a984708SDavid Chisnall _Up* 18927a984708SDavid Chisnall>::type 18937a984708SDavid Chisnall__move_backward(_Tp* __first, _Tp* __last, _Up* __result) 18947a984708SDavid Chisnall{ 18957a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 1896854fa44bSDimitry Andric if (__n > 0) 1897854fa44bSDimitry Andric { 18987a984708SDavid Chisnall __result -= __n; 18997a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1900854fa44bSDimitry Andric } 19017a984708SDavid Chisnall return __result; 19027a984708SDavid Chisnall} 19037a984708SDavid Chisnall 19047a984708SDavid Chisnalltemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 19057a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19067a984708SDavid Chisnall_BidirectionalIterator2 19077a984708SDavid Chisnallmove_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 19087a984708SDavid Chisnall _BidirectionalIterator2 __result) 19097a984708SDavid Chisnall{ 19107a984708SDavid Chisnall return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 19117a984708SDavid Chisnall} 19127a984708SDavid Chisnall 19137a984708SDavid Chisnall// iter_swap 19147a984708SDavid Chisnall 19157a984708SDavid Chisnall// moved to <type_traits> for better swap / noexcept support 19167a984708SDavid Chisnall 19177a984708SDavid Chisnall// transform 19187a984708SDavid Chisnall 19197a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _UnaryOperation> 19207a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19217a984708SDavid Chisnall_OutputIterator 19227a984708SDavid Chisnalltransform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) 19237a984708SDavid Chisnall{ 1924d72607e9SDimitry Andric for (; __first != __last; ++__first, (void) ++__result) 19257a984708SDavid Chisnall *__result = __op(*__first); 19267a984708SDavid Chisnall return __result; 19277a984708SDavid Chisnall} 19287a984708SDavid Chisnall 19297a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation> 19307a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19317a984708SDavid Chisnall_OutputIterator 19327a984708SDavid Chisnalltransform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, 19337a984708SDavid Chisnall _OutputIterator __result, _BinaryOperation __binary_op) 19347a984708SDavid Chisnall{ 1935d72607e9SDimitry Andric for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result) 19367a984708SDavid Chisnall *__result = __binary_op(*__first1, *__first2); 19377a984708SDavid Chisnall return __result; 19387a984708SDavid Chisnall} 19397a984708SDavid Chisnall 19407a984708SDavid Chisnall// replace 19417a984708SDavid Chisnall 19427a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 19437a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19447a984708SDavid Chisnallvoid 19457a984708SDavid Chisnallreplace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) 19467a984708SDavid Chisnall{ 19477a984708SDavid Chisnall for (; __first != __last; ++__first) 19487a984708SDavid Chisnall if (*__first == __old_value) 19497a984708SDavid Chisnall *__first = __new_value; 19507a984708SDavid Chisnall} 19517a984708SDavid Chisnall 19527a984708SDavid Chisnall// replace_if 19537a984708SDavid Chisnall 19547a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate, class _Tp> 19557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19567a984708SDavid Chisnallvoid 19577a984708SDavid Chisnallreplace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) 19587a984708SDavid Chisnall{ 19597a984708SDavid Chisnall for (; __first != __last; ++__first) 19607a984708SDavid Chisnall if (__pred(*__first)) 19617a984708SDavid Chisnall *__first = __new_value; 19627a984708SDavid Chisnall} 19637a984708SDavid Chisnall 19647a984708SDavid Chisnall// replace_copy 19657a984708SDavid Chisnall 19667a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Tp> 19677a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19687a984708SDavid Chisnall_OutputIterator 19697a984708SDavid Chisnallreplace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 19707a984708SDavid Chisnall const _Tp& __old_value, const _Tp& __new_value) 19717a984708SDavid Chisnall{ 1972d72607e9SDimitry Andric for (; __first != __last; ++__first, (void) ++__result) 19737a984708SDavid Chisnall if (*__first == __old_value) 19747a984708SDavid Chisnall *__result = __new_value; 19757a984708SDavid Chisnall else 19767a984708SDavid Chisnall *__result = *__first; 19777a984708SDavid Chisnall return __result; 19787a984708SDavid Chisnall} 19797a984708SDavid Chisnall 19807a984708SDavid Chisnall// replace_copy_if 19817a984708SDavid Chisnall 19827a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp> 19837a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19847a984708SDavid Chisnall_OutputIterator 19857a984708SDavid Chisnallreplace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 19867a984708SDavid Chisnall _Predicate __pred, const _Tp& __new_value) 19877a984708SDavid Chisnall{ 1988d72607e9SDimitry Andric for (; __first != __last; ++__first, (void) ++__result) 19897a984708SDavid Chisnall if (__pred(*__first)) 19907a984708SDavid Chisnall *__result = __new_value; 19917a984708SDavid Chisnall else 19927a984708SDavid Chisnall *__result = *__first; 19937a984708SDavid Chisnall return __result; 19947a984708SDavid Chisnall} 19957a984708SDavid Chisnall 19967a984708SDavid Chisnall// fill_n 19977a984708SDavid Chisnall 19987a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp> 19997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20007a984708SDavid Chisnall_OutputIterator 20014f7ab58eSDimitry Andric__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 20027a984708SDavid Chisnall{ 2003d72607e9SDimitry Andric for (; __n > 0; ++__first, (void) --__n) 20047a984708SDavid Chisnall *__first = __value_; 20057a984708SDavid Chisnall return __first; 20067a984708SDavid Chisnall} 20077a984708SDavid Chisnall 20084f7ab58eSDimitry Andrictemplate <class _Tp, class _Size, class _Up> 20097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20104f7ab58eSDimitry Andrictypename enable_if 20114f7ab58eSDimitry Andric< 20124f7ab58eSDimitry Andric is_integral<_Tp>::value && sizeof(_Tp) == 1 && 20134f7ab58eSDimitry Andric !is_same<_Tp, bool>::value && 20144f7ab58eSDimitry Andric is_integral<_Up>::value && sizeof(_Up) == 1, 20154f7ab58eSDimitry Andric _Tp* 20164f7ab58eSDimitry Andric>::type 20174f7ab58eSDimitry Andric__fill_n(_Tp* __first, _Size __n,_Up __value_) 20187a984708SDavid Chisnall{ 20197a984708SDavid Chisnall if (__n > 0) 20207a984708SDavid Chisnall _VSTD::memset(__first, (unsigned char)__value_, (size_t)(__n)); 20217a984708SDavid Chisnall return __first + __n; 20227a984708SDavid Chisnall} 20237a984708SDavid Chisnall 20247a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp> 20257a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20267a984708SDavid Chisnall_OutputIterator 20277a984708SDavid Chisnallfill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 20287a984708SDavid Chisnall{ 2029854fa44bSDimitry Andric return _VSTD::__fill_n(__first, __convert_to_integral(__n), __value_); 20307a984708SDavid Chisnall} 20317a984708SDavid Chisnall 20327a984708SDavid Chisnall// fill 20337a984708SDavid Chisnall 20347a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 20357a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20367a984708SDavid Chisnallvoid 20377a984708SDavid Chisnall__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag) 20387a984708SDavid Chisnall{ 20397a984708SDavid Chisnall for (; __first != __last; ++__first) 20407a984708SDavid Chisnall *__first = __value_; 20417a984708SDavid Chisnall} 20427a984708SDavid Chisnall 20437a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Tp> 20447a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20457a984708SDavid Chisnallvoid 20467a984708SDavid Chisnall__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag) 20477a984708SDavid Chisnall{ 20487a984708SDavid Chisnall _VSTD::fill_n(__first, __last - __first, __value_); 20497a984708SDavid Chisnall} 20507a984708SDavid Chisnall 20517a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 20527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20537a984708SDavid Chisnallvoid 20547a984708SDavid Chisnallfill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 20557a984708SDavid Chisnall{ 20567a984708SDavid Chisnall _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category()); 20577a984708SDavid Chisnall} 20587a984708SDavid Chisnall 20597a984708SDavid Chisnall// generate 20607a984708SDavid Chisnall 20617a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Generator> 20627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20637a984708SDavid Chisnallvoid 20647a984708SDavid Chisnallgenerate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) 20657a984708SDavid Chisnall{ 20667a984708SDavid Chisnall for (; __first != __last; ++__first) 20677a984708SDavid Chisnall *__first = __gen(); 20687a984708SDavid Chisnall} 20697a984708SDavid Chisnall 20707a984708SDavid Chisnall// generate_n 20717a984708SDavid Chisnall 20727a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Generator> 20737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20747a984708SDavid Chisnall_OutputIterator 2075854fa44bSDimitry Andricgenerate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen) 20767a984708SDavid Chisnall{ 2077854fa44bSDimitry Andric typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; 2078854fa44bSDimitry Andric _IntegralSize __n = __orig_n; 2079d72607e9SDimitry Andric for (; __n > 0; ++__first, (void) --__n) 20807a984708SDavid Chisnall *__first = __gen(); 20817a984708SDavid Chisnall return __first; 20827a984708SDavid Chisnall} 20837a984708SDavid Chisnall 20847a984708SDavid Chisnall// remove 20857a984708SDavid Chisnall 20867a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 20877a984708SDavid Chisnall_ForwardIterator 20887a984708SDavid Chisnallremove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 20897a984708SDavid Chisnall{ 20907a984708SDavid Chisnall __first = _VSTD::find(__first, __last, __value_); 20917a984708SDavid Chisnall if (__first != __last) 20927a984708SDavid Chisnall { 20937a984708SDavid Chisnall _ForwardIterator __i = __first; 20947a984708SDavid Chisnall while (++__i != __last) 20957a984708SDavid Chisnall { 20967a984708SDavid Chisnall if (!(*__i == __value_)) 20977a984708SDavid Chisnall { 20987a984708SDavid Chisnall *__first = _VSTD::move(*__i); 20997a984708SDavid Chisnall ++__first; 21007a984708SDavid Chisnall } 21017a984708SDavid Chisnall } 21027a984708SDavid Chisnall } 21037a984708SDavid Chisnall return __first; 21047a984708SDavid Chisnall} 21057a984708SDavid Chisnall 21067a984708SDavid Chisnall// remove_if 21077a984708SDavid Chisnall 21087a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate> 21097a984708SDavid Chisnall_ForwardIterator 21107a984708SDavid Chisnallremove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 21117a984708SDavid Chisnall{ 21127a984708SDavid Chisnall __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type> 21137a984708SDavid Chisnall (__first, __last, __pred); 21147a984708SDavid Chisnall if (__first != __last) 21157a984708SDavid Chisnall { 21167a984708SDavid Chisnall _ForwardIterator __i = __first; 21177a984708SDavid Chisnall while (++__i != __last) 21187a984708SDavid Chisnall { 21197a984708SDavid Chisnall if (!__pred(*__i)) 21207a984708SDavid Chisnall { 21217a984708SDavid Chisnall *__first = _VSTD::move(*__i); 21227a984708SDavid Chisnall ++__first; 21237a984708SDavid Chisnall } 21247a984708SDavid Chisnall } 21257a984708SDavid Chisnall } 21267a984708SDavid Chisnall return __first; 21277a984708SDavid Chisnall} 21287a984708SDavid Chisnall 21297a984708SDavid Chisnall// remove_copy 21307a984708SDavid Chisnall 21317a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Tp> 21327a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 21337a984708SDavid Chisnall_OutputIterator 21347a984708SDavid Chisnallremove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_) 21357a984708SDavid Chisnall{ 21367a984708SDavid Chisnall for (; __first != __last; ++__first) 21377a984708SDavid Chisnall { 21387a984708SDavid Chisnall if (!(*__first == __value_)) 21397a984708SDavid Chisnall { 21407a984708SDavid Chisnall *__result = *__first; 21417a984708SDavid Chisnall ++__result; 21427a984708SDavid Chisnall } 21437a984708SDavid Chisnall } 21447a984708SDavid Chisnall return __result; 21457a984708SDavid Chisnall} 21467a984708SDavid Chisnall 21477a984708SDavid Chisnall// remove_copy_if 21487a984708SDavid Chisnall 21497a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Predicate> 21507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 21517a984708SDavid Chisnall_OutputIterator 21527a984708SDavid Chisnallremove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) 21537a984708SDavid Chisnall{ 21547a984708SDavid Chisnall for (; __first != __last; ++__first) 21557a984708SDavid Chisnall { 21567a984708SDavid Chisnall if (!__pred(*__first)) 21577a984708SDavid Chisnall { 21587a984708SDavid Chisnall *__result = *__first; 21597a984708SDavid Chisnall ++__result; 21607a984708SDavid Chisnall } 21617a984708SDavid Chisnall } 21627a984708SDavid Chisnall return __result; 21637a984708SDavid Chisnall} 21647a984708SDavid Chisnall 21657a984708SDavid Chisnall// unique 21667a984708SDavid Chisnall 21677a984708SDavid Chisnalltemplate <class _ForwardIterator, class _BinaryPredicate> 21687a984708SDavid Chisnall_ForwardIterator 21697a984708SDavid Chisnallunique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 21707a984708SDavid Chisnall{ 21717a984708SDavid Chisnall __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type> 21727a984708SDavid Chisnall (__first, __last, __pred); 21737a984708SDavid Chisnall if (__first != __last) 21747a984708SDavid Chisnall { 21757a984708SDavid Chisnall // ... a a ? ... 21767a984708SDavid Chisnall // f i 21777a984708SDavid Chisnall _ForwardIterator __i = __first; 21787a984708SDavid Chisnall for (++__i; ++__i != __last;) 21797a984708SDavid Chisnall if (!__pred(*__first, *__i)) 21807a984708SDavid Chisnall *++__first = _VSTD::move(*__i); 21817a984708SDavid Chisnall ++__first; 21827a984708SDavid Chisnall } 21837a984708SDavid Chisnall return __first; 21847a984708SDavid Chisnall} 21857a984708SDavid Chisnall 21867a984708SDavid Chisnalltemplate <class _ForwardIterator> 21877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 21887a984708SDavid Chisnall_ForwardIterator 21897a984708SDavid Chisnallunique(_ForwardIterator __first, _ForwardIterator __last) 21907a984708SDavid Chisnall{ 21917a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type __v; 21927a984708SDavid Chisnall return _VSTD::unique(__first, __last, __equal_to<__v>()); 21937a984708SDavid Chisnall} 21947a984708SDavid Chisnall 21957a984708SDavid Chisnall// unique_copy 21967a984708SDavid Chisnall 21977a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator, class _OutputIterator> 21987a984708SDavid Chisnall_OutputIterator 21997a984708SDavid Chisnall__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 22007a984708SDavid Chisnall input_iterator_tag, output_iterator_tag) 22017a984708SDavid Chisnall{ 22027a984708SDavid Chisnall if (__first != __last) 22037a984708SDavid Chisnall { 22047a984708SDavid Chisnall typename iterator_traits<_InputIterator>::value_type __t(*__first); 22057a984708SDavid Chisnall *__result = __t; 22067a984708SDavid Chisnall ++__result; 22077a984708SDavid Chisnall while (++__first != __last) 22087a984708SDavid Chisnall { 22097a984708SDavid Chisnall if (!__pred(__t, *__first)) 22107a984708SDavid Chisnall { 22117a984708SDavid Chisnall __t = *__first; 22127a984708SDavid Chisnall *__result = __t; 22137a984708SDavid Chisnall ++__result; 22147a984708SDavid Chisnall } 22157a984708SDavid Chisnall } 22167a984708SDavid Chisnall } 22177a984708SDavid Chisnall return __result; 22187a984708SDavid Chisnall} 22197a984708SDavid Chisnall 22207a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator> 22217a984708SDavid Chisnall_OutputIterator 22227a984708SDavid Chisnall__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 22237a984708SDavid Chisnall forward_iterator_tag, output_iterator_tag) 22247a984708SDavid Chisnall{ 22257a984708SDavid Chisnall if (__first != __last) 22267a984708SDavid Chisnall { 22277a984708SDavid Chisnall _ForwardIterator __i = __first; 22287a984708SDavid Chisnall *__result = *__i; 22297a984708SDavid Chisnall ++__result; 22307a984708SDavid Chisnall while (++__first != __last) 22317a984708SDavid Chisnall { 22327a984708SDavid Chisnall if (!__pred(*__i, *__first)) 22337a984708SDavid Chisnall { 22347a984708SDavid Chisnall *__result = *__first; 22357a984708SDavid Chisnall ++__result; 22367a984708SDavid Chisnall __i = __first; 22377a984708SDavid Chisnall } 22387a984708SDavid Chisnall } 22397a984708SDavid Chisnall } 22407a984708SDavid Chisnall return __result; 22417a984708SDavid Chisnall} 22427a984708SDavid Chisnall 22437a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator, class _ForwardIterator> 22447a984708SDavid Chisnall_ForwardIterator 22457a984708SDavid Chisnall__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred, 22467a984708SDavid Chisnall input_iterator_tag, forward_iterator_tag) 22477a984708SDavid Chisnall{ 22487a984708SDavid Chisnall if (__first != __last) 22497a984708SDavid Chisnall { 22507a984708SDavid Chisnall *__result = *__first; 22517a984708SDavid Chisnall while (++__first != __last) 22527a984708SDavid Chisnall if (!__pred(*__result, *__first)) 22537a984708SDavid Chisnall *++__result = *__first; 22547a984708SDavid Chisnall ++__result; 22557a984708SDavid Chisnall } 22567a984708SDavid Chisnall return __result; 22577a984708SDavid Chisnall} 22587a984708SDavid Chisnall 22597a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _BinaryPredicate> 22607a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22617a984708SDavid Chisnall_OutputIterator 22627a984708SDavid Chisnallunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) 22637a984708SDavid Chisnall{ 22647a984708SDavid Chisnall return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type> 22657a984708SDavid Chisnall (__first, __last, __result, __pred, 22667a984708SDavid Chisnall typename iterator_traits<_InputIterator>::iterator_category(), 22677a984708SDavid Chisnall typename iterator_traits<_OutputIterator>::iterator_category()); 22687a984708SDavid Chisnall} 22697a984708SDavid Chisnall 22707a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 22717a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22727a984708SDavid Chisnall_OutputIterator 22737a984708SDavid Chisnallunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 22747a984708SDavid Chisnall{ 22757a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator>::value_type __v; 22767a984708SDavid Chisnall return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>()); 22777a984708SDavid Chisnall} 22787a984708SDavid Chisnall 22797a984708SDavid Chisnall// reverse 22807a984708SDavid Chisnall 22817a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 22827a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22837a984708SDavid Chisnallvoid 22847a984708SDavid Chisnall__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) 22857a984708SDavid Chisnall{ 22867a984708SDavid Chisnall while (__first != __last) 22877a984708SDavid Chisnall { 22887a984708SDavid Chisnall if (__first == --__last) 22897a984708SDavid Chisnall break; 22909729cf09SDimitry Andric _VSTD::iter_swap(__first, __last); 22917a984708SDavid Chisnall ++__first; 22927a984708SDavid Chisnall } 22937a984708SDavid Chisnall} 22947a984708SDavid Chisnall 22957a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 22967a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22977a984708SDavid Chisnallvoid 22987a984708SDavid Chisnall__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) 22997a984708SDavid Chisnall{ 23007a984708SDavid Chisnall if (__first != __last) 23017a984708SDavid Chisnall for (; __first < --__last; ++__first) 23029729cf09SDimitry Andric _VSTD::iter_swap(__first, __last); 23037a984708SDavid Chisnall} 23047a984708SDavid Chisnall 23057a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 23067a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23077a984708SDavid Chisnallvoid 23087a984708SDavid Chisnallreverse(_BidirectionalIterator __first, _BidirectionalIterator __last) 23097a984708SDavid Chisnall{ 23107a984708SDavid Chisnall _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category()); 23117a984708SDavid Chisnall} 23127a984708SDavid Chisnall 23137a984708SDavid Chisnall// reverse_copy 23147a984708SDavid Chisnall 23157a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _OutputIterator> 23167a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23177a984708SDavid Chisnall_OutputIterator 23187a984708SDavid Chisnallreverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 23197a984708SDavid Chisnall{ 23207a984708SDavid Chisnall for (; __first != __last; ++__result) 23217a984708SDavid Chisnall *__result = *--__last; 23227a984708SDavid Chisnall return __result; 23237a984708SDavid Chisnall} 23247a984708SDavid Chisnall 23257a984708SDavid Chisnall// rotate 23267a984708SDavid Chisnall 23277a984708SDavid Chisnalltemplate <class _ForwardIterator> 23287a984708SDavid Chisnall_ForwardIterator 2329936e9439SDimitry Andric__rotate_left(_ForwardIterator __first, _ForwardIterator __last) 23307a984708SDavid Chisnall{ 2331936e9439SDimitry Andric typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 2332936e9439SDimitry Andric value_type __tmp = _VSTD::move(*__first); 2333936e9439SDimitry Andric _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first); 2334936e9439SDimitry Andric *__lm1 = _VSTD::move(__tmp); 2335936e9439SDimitry Andric return __lm1; 2336936e9439SDimitry Andric} 2337936e9439SDimitry Andric 2338936e9439SDimitry Andrictemplate <class _BidirectionalIterator> 2339936e9439SDimitry Andric_BidirectionalIterator 2340936e9439SDimitry Andric__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) 2341936e9439SDimitry Andric{ 2342936e9439SDimitry Andric typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 2343936e9439SDimitry Andric _BidirectionalIterator __lm1 = _VSTD::prev(__last); 2344936e9439SDimitry Andric value_type __tmp = _VSTD::move(*__lm1); 2345936e9439SDimitry Andric _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last); 2346936e9439SDimitry Andric *__first = _VSTD::move(__tmp); 2347936e9439SDimitry Andric return __fp1; 2348936e9439SDimitry Andric} 2349936e9439SDimitry Andric 2350936e9439SDimitry Andrictemplate <class _ForwardIterator> 2351936e9439SDimitry Andric_ForwardIterator 2352936e9439SDimitry Andric__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 2353936e9439SDimitry Andric{ 23547a984708SDavid Chisnall _ForwardIterator __i = __middle; 23557a984708SDavid Chisnall while (true) 23567a984708SDavid Chisnall { 23577a984708SDavid Chisnall swap(*__first, *__i); 23587a984708SDavid Chisnall ++__first; 23597a984708SDavid Chisnall if (++__i == __last) 23607a984708SDavid Chisnall break; 23617a984708SDavid Chisnall if (__first == __middle) 23627a984708SDavid Chisnall __middle = __i; 23637a984708SDavid Chisnall } 23647a984708SDavid Chisnall _ForwardIterator __r = __first; 23657a984708SDavid Chisnall if (__first != __middle) 23667a984708SDavid Chisnall { 23677a984708SDavid Chisnall __i = __middle; 23687a984708SDavid Chisnall while (true) 23697a984708SDavid Chisnall { 23707a984708SDavid Chisnall swap(*__first, *__i); 23717a984708SDavid Chisnall ++__first; 23727a984708SDavid Chisnall if (++__i == __last) 23737a984708SDavid Chisnall { 23747a984708SDavid Chisnall if (__first == __middle) 23757a984708SDavid Chisnall break; 23767a984708SDavid Chisnall __i = __middle; 23777a984708SDavid Chisnall } 23787a984708SDavid Chisnall else if (__first == __middle) 23797a984708SDavid Chisnall __middle = __i; 23807a984708SDavid Chisnall } 23817a984708SDavid Chisnall } 23827a984708SDavid Chisnall return __r; 23837a984708SDavid Chisnall} 23847a984708SDavid Chisnall 23857a984708SDavid Chisnalltemplate<typename _Integral> 23867a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23877a984708SDavid Chisnall_Integral 2388aed8d94eSDimitry Andric__algo_gcd(_Integral __x, _Integral __y) 23897a984708SDavid Chisnall{ 23907a984708SDavid Chisnall do 23917a984708SDavid Chisnall { 23927a984708SDavid Chisnall _Integral __t = __x % __y; 23937a984708SDavid Chisnall __x = __y; 23947a984708SDavid Chisnall __y = __t; 23957a984708SDavid Chisnall } while (__y); 23967a984708SDavid Chisnall return __x; 23977a984708SDavid Chisnall} 23987a984708SDavid Chisnall 23997a984708SDavid Chisnalltemplate<typename _RandomAccessIterator> 24007a984708SDavid Chisnall_RandomAccessIterator 2401936e9439SDimitry Andric__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 24027a984708SDavid Chisnall{ 24037a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 24047a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 24057a984708SDavid Chisnall 24067a984708SDavid Chisnall const difference_type __m1 = __middle - __first; 24077a984708SDavid Chisnall const difference_type __m2 = __last - __middle; 24087a984708SDavid Chisnall if (__m1 == __m2) 24097a984708SDavid Chisnall { 24107a984708SDavid Chisnall _VSTD::swap_ranges(__first, __middle, __middle); 24117a984708SDavid Chisnall return __middle; 24127a984708SDavid Chisnall } 2413aed8d94eSDimitry Andric const difference_type __g = _VSTD::__algo_gcd(__m1, __m2); 24147a984708SDavid Chisnall for (_RandomAccessIterator __p = __first + __g; __p != __first;) 24157a984708SDavid Chisnall { 2416936e9439SDimitry Andric value_type __t(_VSTD::move(*--__p)); 24177a984708SDavid Chisnall _RandomAccessIterator __p1 = __p; 24187a984708SDavid Chisnall _RandomAccessIterator __p2 = __p1 + __m1; 24197a984708SDavid Chisnall do 24207a984708SDavid Chisnall { 2421936e9439SDimitry Andric *__p1 = _VSTD::move(*__p2); 24227a984708SDavid Chisnall __p1 = __p2; 24237a984708SDavid Chisnall const difference_type __d = __last - __p2; 24247a984708SDavid Chisnall if (__m1 < __d) 24257a984708SDavid Chisnall __p2 += __m1; 24267a984708SDavid Chisnall else 24277a984708SDavid Chisnall __p2 = __first + (__m1 - __d); 24287a984708SDavid Chisnall } while (__p2 != __p); 2429936e9439SDimitry Andric *__p1 = _VSTD::move(__t); 24307a984708SDavid Chisnall } 24317a984708SDavid Chisnall return __first + __m2; 24327a984708SDavid Chisnall} 24337a984708SDavid Chisnall 24347a984708SDavid Chisnalltemplate <class _ForwardIterator> 24357a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 24367a984708SDavid Chisnall_ForwardIterator 2437936e9439SDimitry Andric__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, 2438936e9439SDimitry Andric _VSTD::forward_iterator_tag) 2439936e9439SDimitry Andric{ 2440936e9439SDimitry Andric typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type; 2441936e9439SDimitry Andric if (_VSTD::is_trivially_move_assignable<value_type>::value) 2442936e9439SDimitry Andric { 2443936e9439SDimitry Andric if (_VSTD::next(__first) == __middle) 2444936e9439SDimitry Andric return _VSTD::__rotate_left(__first, __last); 2445936e9439SDimitry Andric } 2446936e9439SDimitry Andric return _VSTD::__rotate_forward(__first, __middle, __last); 2447936e9439SDimitry Andric} 2448936e9439SDimitry Andric 2449936e9439SDimitry Andrictemplate <class _BidirectionalIterator> 2450936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 2451936e9439SDimitry Andric_BidirectionalIterator 2452936e9439SDimitry Andric__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 2453936e9439SDimitry Andric _VSTD::bidirectional_iterator_tag) 2454936e9439SDimitry Andric{ 2455936e9439SDimitry Andric typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type; 2456936e9439SDimitry Andric if (_VSTD::is_trivially_move_assignable<value_type>::value) 2457936e9439SDimitry Andric { 2458936e9439SDimitry Andric if (_VSTD::next(__first) == __middle) 2459936e9439SDimitry Andric return _VSTD::__rotate_left(__first, __last); 2460936e9439SDimitry Andric if (_VSTD::next(__middle) == __last) 2461936e9439SDimitry Andric return _VSTD::__rotate_right(__first, __last); 2462936e9439SDimitry Andric } 2463936e9439SDimitry Andric return _VSTD::__rotate_forward(__first, __middle, __last); 2464936e9439SDimitry Andric} 2465936e9439SDimitry Andric 2466936e9439SDimitry Andrictemplate <class _RandomAccessIterator> 2467936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 2468936e9439SDimitry Andric_RandomAccessIterator 2469936e9439SDimitry Andric__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 2470936e9439SDimitry Andric _VSTD::random_access_iterator_tag) 2471936e9439SDimitry Andric{ 2472936e9439SDimitry Andric typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type; 2473936e9439SDimitry Andric if (_VSTD::is_trivially_move_assignable<value_type>::value) 2474936e9439SDimitry Andric { 2475936e9439SDimitry Andric if (_VSTD::next(__first) == __middle) 2476936e9439SDimitry Andric return _VSTD::__rotate_left(__first, __last); 2477936e9439SDimitry Andric if (_VSTD::next(__middle) == __last) 2478936e9439SDimitry Andric return _VSTD::__rotate_right(__first, __last); 2479936e9439SDimitry Andric return _VSTD::__rotate_gcd(__first, __middle, __last); 2480936e9439SDimitry Andric } 2481936e9439SDimitry Andric return _VSTD::__rotate_forward(__first, __middle, __last); 2482936e9439SDimitry Andric} 2483936e9439SDimitry Andric 2484936e9439SDimitry Andrictemplate <class _ForwardIterator> 2485936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 2486936e9439SDimitry Andric_ForwardIterator 24877a984708SDavid Chisnallrotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 24887a984708SDavid Chisnall{ 2489936e9439SDimitry Andric if (__first == __middle) 2490936e9439SDimitry Andric return __last; 2491936e9439SDimitry Andric if (__middle == __last) 2492936e9439SDimitry Andric return __first; 24937a984708SDavid Chisnall return _VSTD::__rotate(__first, __middle, __last, 2494936e9439SDimitry Andric typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category()); 24957a984708SDavid Chisnall} 24967a984708SDavid Chisnall 24977a984708SDavid Chisnall// rotate_copy 24987a984708SDavid Chisnall 24997a984708SDavid Chisnalltemplate <class _ForwardIterator, class _OutputIterator> 25007a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 25017a984708SDavid Chisnall_OutputIterator 25027a984708SDavid Chisnallrotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) 25037a984708SDavid Chisnall{ 25047a984708SDavid Chisnall return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result)); 25057a984708SDavid Chisnall} 25067a984708SDavid Chisnall 25077a984708SDavid Chisnall// min_element 25087a984708SDavid Chisnall 25097a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 2510d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25117a984708SDavid Chisnall_ForwardIterator 2512854fa44bSDimitry Andricmin_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 25137a984708SDavid Chisnall{ 25147a984708SDavid Chisnall if (__first != __last) 25157a984708SDavid Chisnall { 25167a984708SDavid Chisnall _ForwardIterator __i = __first; 25177a984708SDavid Chisnall while (++__i != __last) 25187a984708SDavid Chisnall if (__comp(*__i, *__first)) 25197a984708SDavid Chisnall __first = __i; 25207a984708SDavid Chisnall } 25217a984708SDavid Chisnall return __first; 25227a984708SDavid Chisnall} 25237a984708SDavid Chisnall 25247a984708SDavid Chisnalltemplate <class _ForwardIterator> 2525854fa44bSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25267a984708SDavid Chisnall_ForwardIterator 25277a984708SDavid Chisnallmin_element(_ForwardIterator __first, _ForwardIterator __last) 25287a984708SDavid Chisnall{ 2529854fa44bSDimitry Andric return _VSTD::min_element(__first, __last, 25307a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type>()); 25317a984708SDavid Chisnall} 25327a984708SDavid Chisnall 25337a984708SDavid Chisnall// min 25347a984708SDavid Chisnall 25357a984708SDavid Chisnalltemplate <class _Tp, class _Compare> 2536d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25377a984708SDavid Chisnallconst _Tp& 25387a984708SDavid Chisnallmin(const _Tp& __a, const _Tp& __b, _Compare __comp) 25397a984708SDavid Chisnall{ 25407a984708SDavid Chisnall return __comp(__b, __a) ? __b : __a; 25417a984708SDavid Chisnall} 25427a984708SDavid Chisnall 25437a984708SDavid Chisnalltemplate <class _Tp> 2544d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25457a984708SDavid Chisnallconst _Tp& 25467a984708SDavid Chisnallmin(const _Tp& __a, const _Tp& __b) 25477a984708SDavid Chisnall{ 25487a984708SDavid Chisnall return _VSTD::min(__a, __b, __less<_Tp>()); 25497a984708SDavid Chisnall} 25507a984708SDavid Chisnall 25517a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 25527a984708SDavid Chisnall 25537a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 2554d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25557a984708SDavid Chisnall_Tp 25567a984708SDavid Chisnallmin(initializer_list<_Tp> __t, _Compare __comp) 25577a984708SDavid Chisnall{ 2558854fa44bSDimitry Andric return *_VSTD::min_element(__t.begin(), __t.end(), __comp); 25597a984708SDavid Chisnall} 25607a984708SDavid Chisnall 25617a984708SDavid Chisnalltemplate<class _Tp> 2562d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25637a984708SDavid Chisnall_Tp 25647a984708SDavid Chisnallmin(initializer_list<_Tp> __t) 25657a984708SDavid Chisnall{ 2566854fa44bSDimitry Andric return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>()); 25677a984708SDavid Chisnall} 25687a984708SDavid Chisnall 25697a984708SDavid Chisnall#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 25707a984708SDavid Chisnall 25717a984708SDavid Chisnall// max_element 25727a984708SDavid Chisnall 25737a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 2574d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25757a984708SDavid Chisnall_ForwardIterator 2576854fa44bSDimitry Andricmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 25777a984708SDavid Chisnall{ 25787a984708SDavid Chisnall if (__first != __last) 25797a984708SDavid Chisnall { 25807a984708SDavid Chisnall _ForwardIterator __i = __first; 25817a984708SDavid Chisnall while (++__i != __last) 25827a984708SDavid Chisnall if (__comp(*__first, *__i)) 25837a984708SDavid Chisnall __first = __i; 25847a984708SDavid Chisnall } 25857a984708SDavid Chisnall return __first; 25867a984708SDavid Chisnall} 25877a984708SDavid Chisnall 2588d72607e9SDimitry Andric 25897a984708SDavid Chisnalltemplate <class _ForwardIterator> 2590854fa44bSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 25917a984708SDavid Chisnall_ForwardIterator 25927a984708SDavid Chisnallmax_element(_ForwardIterator __first, _ForwardIterator __last) 25937a984708SDavid Chisnall{ 2594854fa44bSDimitry Andric return _VSTD::max_element(__first, __last, 25957a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type>()); 25967a984708SDavid Chisnall} 25977a984708SDavid Chisnall 25987a984708SDavid Chisnall// max 25997a984708SDavid Chisnall 26007a984708SDavid Chisnalltemplate <class _Tp, class _Compare> 2601d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 26027a984708SDavid Chisnallconst _Tp& 26037a984708SDavid Chisnallmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 26047a984708SDavid Chisnall{ 26057a984708SDavid Chisnall return __comp(__a, __b) ? __b : __a; 26067a984708SDavid Chisnall} 26077a984708SDavid Chisnall 26087a984708SDavid Chisnalltemplate <class _Tp> 2609d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 26107a984708SDavid Chisnallconst _Tp& 26117a984708SDavid Chisnallmax(const _Tp& __a, const _Tp& __b) 26127a984708SDavid Chisnall{ 26137a984708SDavid Chisnall return _VSTD::max(__a, __b, __less<_Tp>()); 26147a984708SDavid Chisnall} 26157a984708SDavid Chisnall 26167a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 26177a984708SDavid Chisnall 26187a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 2619d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 26207a984708SDavid Chisnall_Tp 26217a984708SDavid Chisnallmax(initializer_list<_Tp> __t, _Compare __comp) 26227a984708SDavid Chisnall{ 2623854fa44bSDimitry Andric return *_VSTD::max_element(__t.begin(), __t.end(), __comp); 26247a984708SDavid Chisnall} 26257a984708SDavid Chisnall 26267a984708SDavid Chisnalltemplate<class _Tp> 2627d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 26287a984708SDavid Chisnall_Tp 26297a984708SDavid Chisnallmax(initializer_list<_Tp> __t) 26307a984708SDavid Chisnall{ 2631854fa44bSDimitry Andric return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>()); 26327a984708SDavid Chisnall} 26337a984708SDavid Chisnall 26347a984708SDavid Chisnall#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 26357a984708SDavid Chisnall 26367c82a1ecSDimitry Andric#if _LIBCPP_STD_VER > 14 26377c82a1ecSDimitry Andric// clamp 26387c82a1ecSDimitry Andrictemplate<class _Tp, class _Compare> 26397c82a1ecSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 26407c82a1ecSDimitry Andricconst _Tp& 26417c82a1ecSDimitry Andricclamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp) 26427c82a1ecSDimitry Andric{ 26437c82a1ecSDimitry Andric _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp"); 26447c82a1ecSDimitry Andric return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v; 26457c82a1ecSDimitry Andric 26467c82a1ecSDimitry Andric} 26477c82a1ecSDimitry Andric 26487c82a1ecSDimitry Andrictemplate<class _Tp> 26497c82a1ecSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 26507c82a1ecSDimitry Andricconst _Tp& 26517c82a1ecSDimitry Andricclamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi) 26527c82a1ecSDimitry Andric{ 26537c82a1ecSDimitry Andric return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>()); 26547c82a1ecSDimitry Andric} 26557c82a1ecSDimitry Andric#endif 26567c82a1ecSDimitry Andric 26577a984708SDavid Chisnall// minmax_element 26587a984708SDavid Chisnall 26597a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 2660854fa44bSDimitry Andric_LIBCPP_CONSTEXPR_AFTER_CXX11 26617a984708SDavid Chisnallstd::pair<_ForwardIterator, _ForwardIterator> 26627a984708SDavid Chisnallminmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 26637a984708SDavid Chisnall{ 26647a984708SDavid Chisnall std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first); 26657a984708SDavid Chisnall if (__first != __last) 26667a984708SDavid Chisnall { 26677a984708SDavid Chisnall if (++__first != __last) 26687a984708SDavid Chisnall { 26697a984708SDavid Chisnall if (__comp(*__first, *__result.first)) 26707a984708SDavid Chisnall __result.first = __first; 26717a984708SDavid Chisnall else 26727a984708SDavid Chisnall __result.second = __first; 26737a984708SDavid Chisnall while (++__first != __last) 26747a984708SDavid Chisnall { 26757a984708SDavid Chisnall _ForwardIterator __i = __first; 26767a984708SDavid Chisnall if (++__first == __last) 26777a984708SDavid Chisnall { 26787a984708SDavid Chisnall if (__comp(*__i, *__result.first)) 26797a984708SDavid Chisnall __result.first = __i; 26807a984708SDavid Chisnall else if (!__comp(*__i, *__result.second)) 26817a984708SDavid Chisnall __result.second = __i; 26827a984708SDavid Chisnall break; 26837a984708SDavid Chisnall } 26847a984708SDavid Chisnall else 26857a984708SDavid Chisnall { 26867a984708SDavid Chisnall if (__comp(*__first, *__i)) 26877a984708SDavid Chisnall { 26887a984708SDavid Chisnall if (__comp(*__first, *__result.first)) 26897a984708SDavid Chisnall __result.first = __first; 26907a984708SDavid Chisnall if (!__comp(*__i, *__result.second)) 26917a984708SDavid Chisnall __result.second = __i; 26927a984708SDavid Chisnall } 26937a984708SDavid Chisnall else 26947a984708SDavid Chisnall { 26957a984708SDavid Chisnall if (__comp(*__i, *__result.first)) 26967a984708SDavid Chisnall __result.first = __i; 26977a984708SDavid Chisnall if (!__comp(*__first, *__result.second)) 26987a984708SDavid Chisnall __result.second = __first; 26997a984708SDavid Chisnall } 27007a984708SDavid Chisnall } 27017a984708SDavid Chisnall } 27027a984708SDavid Chisnall } 27037a984708SDavid Chisnall } 27047a984708SDavid Chisnall return __result; 27057a984708SDavid Chisnall} 27067a984708SDavid Chisnall 27077a984708SDavid Chisnalltemplate <class _ForwardIterator> 2708854fa44bSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 27097a984708SDavid Chisnallstd::pair<_ForwardIterator, _ForwardIterator> 27107a984708SDavid Chisnallminmax_element(_ForwardIterator __first, _ForwardIterator __last) 27117a984708SDavid Chisnall{ 2712d72607e9SDimitry Andric return _VSTD::minmax_element(__first, __last, 2713d72607e9SDimitry Andric __less<typename iterator_traits<_ForwardIterator>::value_type>()); 27147a984708SDavid Chisnall} 27157a984708SDavid Chisnall 27167a984708SDavid Chisnall// minmax 27177a984708SDavid Chisnall 27187a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 2719d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 27207a984708SDavid Chisnallpair<const _Tp&, const _Tp&> 27217a984708SDavid Chisnallminmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 27227a984708SDavid Chisnall{ 27237a984708SDavid Chisnall return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) : 27247a984708SDavid Chisnall pair<const _Tp&, const _Tp&>(__a, __b); 27257a984708SDavid Chisnall} 27267a984708SDavid Chisnall 27277a984708SDavid Chisnalltemplate<class _Tp> 2728d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 27297a984708SDavid Chisnallpair<const _Tp&, const _Tp&> 27307a984708SDavid Chisnallminmax(const _Tp& __a, const _Tp& __b) 27317a984708SDavid Chisnall{ 27327a984708SDavid Chisnall return _VSTD::minmax(__a, __b, __less<_Tp>()); 27337a984708SDavid Chisnall} 27347a984708SDavid Chisnall 27357a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 27367a984708SDavid Chisnall 27377a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 2738d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 27397a984708SDavid Chisnallpair<_Tp, _Tp> 27407a984708SDavid Chisnallminmax(initializer_list<_Tp> __t, _Compare __comp) 27417a984708SDavid Chisnall{ 2742d72607e9SDimitry Andric typedef typename initializer_list<_Tp>::const_iterator _Iter; 2743d72607e9SDimitry Andric _Iter __first = __t.begin(); 2744d72607e9SDimitry Andric _Iter __last = __t.end(); 2745d72607e9SDimitry Andric std::pair<_Tp, _Tp> __result(*__first, *__first); 2746d72607e9SDimitry Andric 2747d72607e9SDimitry Andric ++__first; 2748d72607e9SDimitry Andric if (__t.size() % 2 == 0) 2749d72607e9SDimitry Andric { 2750d72607e9SDimitry Andric if (__comp(*__first, __result.first)) 2751d72607e9SDimitry Andric __result.first = *__first; 2752d72607e9SDimitry Andric else 2753d72607e9SDimitry Andric __result.second = *__first; 2754d72607e9SDimitry Andric ++__first; 2755d72607e9SDimitry Andric } 2756d72607e9SDimitry Andric 2757d72607e9SDimitry Andric while (__first != __last) 2758d72607e9SDimitry Andric { 2759d72607e9SDimitry Andric _Tp __prev = *__first++; 2760854fa44bSDimitry Andric if (__comp(*__first, __prev)) { 2761854fa44bSDimitry Andric if ( __comp(*__first, __result.first)) __result.first = *__first; 2762854fa44bSDimitry Andric if (!__comp(__prev, __result.second)) __result.second = __prev; 2763d72607e9SDimitry Andric } 2764d72607e9SDimitry Andric else { 2765854fa44bSDimitry Andric if ( __comp(__prev, __result.first)) __result.first = __prev; 2766854fa44bSDimitry Andric if (!__comp(*__first, __result.second)) __result.second = *__first; 2767d72607e9SDimitry Andric } 2768d72607e9SDimitry Andric 2769d72607e9SDimitry Andric __first++; 2770d72607e9SDimitry Andric } 2771d72607e9SDimitry Andric return __result; 2772d72607e9SDimitry Andric} 2773d72607e9SDimitry Andric 2774d72607e9SDimitry Andrictemplate<class _Tp> 2775d72607e9SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 2776d72607e9SDimitry Andricpair<_Tp, _Tp> 2777d72607e9SDimitry Andricminmax(initializer_list<_Tp> __t) 2778d72607e9SDimitry Andric{ 2779d72607e9SDimitry Andric return _VSTD::minmax(__t, __less<_Tp>()); 27807a984708SDavid Chisnall} 27817a984708SDavid Chisnall 27827a984708SDavid Chisnall#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 27837a984708SDavid Chisnall 27847a984708SDavid Chisnall// random_shuffle 27857a984708SDavid Chisnall 27867a984708SDavid Chisnall// __independent_bits_engine 27877a984708SDavid Chisnall 278894e3ee44SDavid Chisnalltemplate <unsigned long long _Xp, size_t _Rp> 27897a984708SDavid Chisnallstruct __log2_imp 27907a984708SDavid Chisnall{ 279194e3ee44SDavid Chisnall static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp 279294e3ee44SDavid Chisnall : __log2_imp<_Xp, _Rp - 1>::value; 27937a984708SDavid Chisnall}; 27947a984708SDavid Chisnall 279594e3ee44SDavid Chisnalltemplate <unsigned long long _Xp> 279694e3ee44SDavid Chisnallstruct __log2_imp<_Xp, 0> 27977a984708SDavid Chisnall{ 27987a984708SDavid Chisnall static const size_t value = 0; 27997a984708SDavid Chisnall}; 28007a984708SDavid Chisnall 280194e3ee44SDavid Chisnalltemplate <size_t _Rp> 280294e3ee44SDavid Chisnallstruct __log2_imp<0, _Rp> 28037a984708SDavid Chisnall{ 280494e3ee44SDavid Chisnall static const size_t value = _Rp + 1; 28057a984708SDavid Chisnall}; 28067a984708SDavid Chisnall 280794e3ee44SDavid Chisnalltemplate <class _UI, _UI _Xp> 28087a984708SDavid Chisnallstruct __log2 28097a984708SDavid Chisnall{ 281094e3ee44SDavid Chisnall static const size_t value = __log2_imp<_Xp, 28117a984708SDavid Chisnall sizeof(_UI) * __CHAR_BIT__ - 1>::value; 28127a984708SDavid Chisnall}; 28137a984708SDavid Chisnall 28147a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 28157a984708SDavid Chisnallclass __independent_bits_engine 28167a984708SDavid Chisnall{ 28177a984708SDavid Chisnallpublic: 28187a984708SDavid Chisnall // types 28197a984708SDavid Chisnall typedef _UIntType result_type; 28207a984708SDavid Chisnall 28217a984708SDavid Chisnallprivate: 28227a984708SDavid Chisnall typedef typename _Engine::result_type _Engine_result_type; 28237a984708SDavid Chisnall typedef typename conditional 28247a984708SDavid Chisnall < 28257a984708SDavid Chisnall sizeof(_Engine_result_type) <= sizeof(result_type), 28267a984708SDavid Chisnall result_type, 28277a984708SDavid Chisnall _Engine_result_type 28287a984708SDavid Chisnall >::type _Working_result_type; 28297a984708SDavid Chisnall 28307a984708SDavid Chisnall _Engine& __e_; 28317a984708SDavid Chisnall size_t __w_; 28327a984708SDavid Chisnall size_t __w0_; 28337a984708SDavid Chisnall size_t __n_; 28347a984708SDavid Chisnall size_t __n0_; 28357a984708SDavid Chisnall _Working_result_type __y0_; 28367a984708SDavid Chisnall _Working_result_type __y1_; 28377a984708SDavid Chisnall _Engine_result_type __mask0_; 28387a984708SDavid Chisnall _Engine_result_type __mask1_; 28397a984708SDavid Chisnall 2840b03f91a8SDavid Chisnall#ifdef _LIBCPP_HAS_NO_CONSTEXPR 284194e3ee44SDavid Chisnall static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min 28427a984708SDavid Chisnall + _Working_result_type(1); 2843b03f91a8SDavid Chisnall#else 2844b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() 2845b03f91a8SDavid Chisnall + _Working_result_type(1); 2846b03f91a8SDavid Chisnall#endif 2847b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value; 2848b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits; 2849b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; 28507a984708SDavid Chisnall 28517a984708SDavid Chisnallpublic: 28527a984708SDavid Chisnall // constructors and seeding functions 28537a984708SDavid Chisnall __independent_bits_engine(_Engine& __e, size_t __w); 28547a984708SDavid Chisnall 28557a984708SDavid Chisnall // generating functions 285694e3ee44SDavid Chisnall result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());} 28577a984708SDavid Chisnall 28587a984708SDavid Chisnallprivate: 28597a984708SDavid Chisnall result_type __eval(false_type); 28607a984708SDavid Chisnall result_type __eval(true_type); 28617a984708SDavid Chisnall}; 28627a984708SDavid Chisnall 28637a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 28647a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType> 28657a984708SDavid Chisnall ::__independent_bits_engine(_Engine& __e, size_t __w) 28667a984708SDavid Chisnall : __e_(__e), 28677a984708SDavid Chisnall __w_(__w) 28687a984708SDavid Chisnall{ 28697a984708SDavid Chisnall __n_ = __w_ / __m + (__w_ % __m != 0); 28707a984708SDavid Chisnall __w0_ = __w_ / __n_; 287194e3ee44SDavid Chisnall if (_Rp == 0) 287294e3ee44SDavid Chisnall __y0_ = _Rp; 28737a984708SDavid Chisnall else if (__w0_ < _WDt) 287494e3ee44SDavid Chisnall __y0_ = (_Rp >> __w0_) << __w0_; 28757a984708SDavid Chisnall else 28767a984708SDavid Chisnall __y0_ = 0; 287794e3ee44SDavid Chisnall if (_Rp - __y0_ > __y0_ / __n_) 28787a984708SDavid Chisnall { 28797a984708SDavid Chisnall ++__n_; 28807a984708SDavid Chisnall __w0_ = __w_ / __n_; 28817a984708SDavid Chisnall if (__w0_ < _WDt) 288294e3ee44SDavid Chisnall __y0_ = (_Rp >> __w0_) << __w0_; 28837a984708SDavid Chisnall else 28847a984708SDavid Chisnall __y0_ = 0; 28857a984708SDavid Chisnall } 28867a984708SDavid Chisnall __n0_ = __n_ - __w_ % __n_; 28877a984708SDavid Chisnall if (__w0_ < _WDt - 1) 288894e3ee44SDavid Chisnall __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1); 28897a984708SDavid Chisnall else 28907a984708SDavid Chisnall __y1_ = 0; 28917a984708SDavid Chisnall __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) : 28927a984708SDavid Chisnall _Engine_result_type(0); 28937a984708SDavid Chisnall __mask1_ = __w0_ < _EDt - 1 ? 28947a984708SDavid Chisnall _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) : 28957a984708SDavid Chisnall _Engine_result_type(~0); 28967a984708SDavid Chisnall} 28977a984708SDavid Chisnall 28987a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 28997a984708SDavid Chisnallinline 29007a984708SDavid Chisnall_UIntType 29017a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>::__eval(false_type) 29027a984708SDavid Chisnall{ 29037a984708SDavid Chisnall return static_cast<result_type>(__e_() & __mask0_); 29047a984708SDavid Chisnall} 29057a984708SDavid Chisnall 29067a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 29077a984708SDavid Chisnall_UIntType 29087a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>::__eval(true_type) 29097a984708SDavid Chisnall{ 291094e3ee44SDavid Chisnall result_type _Sp = 0; 29117a984708SDavid Chisnall for (size_t __k = 0; __k < __n0_; ++__k) 29127a984708SDavid Chisnall { 29137a984708SDavid Chisnall _Engine_result_type __u; 29147a984708SDavid Chisnall do 29157a984708SDavid Chisnall { 29167a984708SDavid Chisnall __u = __e_() - _Engine::min(); 29177a984708SDavid Chisnall } while (__u >= __y0_); 29187a984708SDavid Chisnall if (__w0_ < _WDt) 291994e3ee44SDavid Chisnall _Sp <<= __w0_; 29207a984708SDavid Chisnall else 292194e3ee44SDavid Chisnall _Sp = 0; 292294e3ee44SDavid Chisnall _Sp += __u & __mask0_; 29237a984708SDavid Chisnall } 29247a984708SDavid Chisnall for (size_t __k = __n0_; __k < __n_; ++__k) 29257a984708SDavid Chisnall { 29267a984708SDavid Chisnall _Engine_result_type __u; 29277a984708SDavid Chisnall do 29287a984708SDavid Chisnall { 29297a984708SDavid Chisnall __u = __e_() - _Engine::min(); 29307a984708SDavid Chisnall } while (__u >= __y1_); 29317a984708SDavid Chisnall if (__w0_ < _WDt - 1) 293294e3ee44SDavid Chisnall _Sp <<= __w0_ + 1; 29337a984708SDavid Chisnall else 293494e3ee44SDavid Chisnall _Sp = 0; 293594e3ee44SDavid Chisnall _Sp += __u & __mask1_; 29367a984708SDavid Chisnall } 293794e3ee44SDavid Chisnall return _Sp; 29387a984708SDavid Chisnall} 29397a984708SDavid Chisnall 29407a984708SDavid Chisnall// uniform_int_distribution 29417a984708SDavid Chisnall 29427a984708SDavid Chisnalltemplate<class _IntType = int> 29437a984708SDavid Chisnallclass uniform_int_distribution 29447a984708SDavid Chisnall{ 29457a984708SDavid Chisnallpublic: 29467a984708SDavid Chisnall // types 29477a984708SDavid Chisnall typedef _IntType result_type; 29487a984708SDavid Chisnall 29497a984708SDavid Chisnall class param_type 29507a984708SDavid Chisnall { 29517a984708SDavid Chisnall result_type __a_; 29527a984708SDavid Chisnall result_type __b_; 29537a984708SDavid Chisnall public: 29547a984708SDavid Chisnall typedef uniform_int_distribution distribution_type; 29557a984708SDavid Chisnall 29567a984708SDavid Chisnall explicit param_type(result_type __a = 0, 29577a984708SDavid Chisnall result_type __b = numeric_limits<result_type>::max()) 29587a984708SDavid Chisnall : __a_(__a), __b_(__b) {} 29597a984708SDavid Chisnall 29607a984708SDavid Chisnall result_type a() const {return __a_;} 29617a984708SDavid Chisnall result_type b() const {return __b_;} 29627a984708SDavid Chisnall 29637a984708SDavid Chisnall friend bool operator==(const param_type& __x, const param_type& __y) 29647a984708SDavid Chisnall {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} 29657a984708SDavid Chisnall friend bool operator!=(const param_type& __x, const param_type& __y) 29667a984708SDavid Chisnall {return !(__x == __y);} 29677a984708SDavid Chisnall }; 29687a984708SDavid Chisnall 29697a984708SDavid Chisnallprivate: 29707a984708SDavid Chisnall param_type __p_; 29717a984708SDavid Chisnall 29727a984708SDavid Chisnallpublic: 29737a984708SDavid Chisnall // constructors and reset functions 29747a984708SDavid Chisnall explicit uniform_int_distribution(result_type __a = 0, 29757a984708SDavid Chisnall result_type __b = numeric_limits<result_type>::max()) 29767a984708SDavid Chisnall : __p_(param_type(__a, __b)) {} 29777a984708SDavid Chisnall explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {} 29787a984708SDavid Chisnall void reset() {} 29797a984708SDavid Chisnall 29807a984708SDavid Chisnall // generating functions 29817a984708SDavid Chisnall template<class _URNG> result_type operator()(_URNG& __g) 29827a984708SDavid Chisnall {return (*this)(__g, __p_);} 29837a984708SDavid Chisnall template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p); 29847a984708SDavid Chisnall 29857a984708SDavid Chisnall // property functions 29867a984708SDavid Chisnall result_type a() const {return __p_.a();} 29877a984708SDavid Chisnall result_type b() const {return __p_.b();} 29887a984708SDavid Chisnall 29897a984708SDavid Chisnall param_type param() const {return __p_;} 29907a984708SDavid Chisnall void param(const param_type& __p) {__p_ = __p;} 29917a984708SDavid Chisnall 29927a984708SDavid Chisnall result_type min() const {return a();} 29937a984708SDavid Chisnall result_type max() const {return b();} 29947a984708SDavid Chisnall 29957a984708SDavid Chisnall friend bool operator==(const uniform_int_distribution& __x, 29967a984708SDavid Chisnall const uniform_int_distribution& __y) 29977a984708SDavid Chisnall {return __x.__p_ == __y.__p_;} 29987a984708SDavid Chisnall friend bool operator!=(const uniform_int_distribution& __x, 29997a984708SDavid Chisnall const uniform_int_distribution& __y) 30007a984708SDavid Chisnall {return !(__x == __y);} 30017a984708SDavid Chisnall}; 30027a984708SDavid Chisnall 30037a984708SDavid Chisnalltemplate<class _IntType> 30047a984708SDavid Chisnalltemplate<class _URNG> 30057a984708SDavid Chisnalltypename uniform_int_distribution<_IntType>::result_type 30067a984708SDavid Chisnalluniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) 30077a984708SDavid Chisnall{ 30087a984708SDavid Chisnall typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), 30097a984708SDavid Chisnall uint32_t, uint64_t>::type _UIntType; 301094e3ee44SDavid Chisnall const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1); 301194e3ee44SDavid Chisnall if (_Rp == 1) 30127a984708SDavid Chisnall return __p.a(); 30137a984708SDavid Chisnall const size_t _Dt = numeric_limits<_UIntType>::digits; 30147a984708SDavid Chisnall typedef __independent_bits_engine<_URNG, _UIntType> _Eng; 301594e3ee44SDavid Chisnall if (_Rp == 0) 30167a984708SDavid Chisnall return static_cast<result_type>(_Eng(__g, _Dt)()); 301794e3ee44SDavid Chisnall size_t __w = _Dt - __clz(_Rp) - 1; 30189729cf09SDimitry Andric if ((_Rp & (std::numeric_limits<_UIntType>::max() >> (_Dt - __w))) != 0) 30197a984708SDavid Chisnall ++__w; 30207a984708SDavid Chisnall _Eng __e(__g, __w); 30217a984708SDavid Chisnall _UIntType __u; 30227a984708SDavid Chisnall do 30237a984708SDavid Chisnall { 30247a984708SDavid Chisnall __u = __e(); 302594e3ee44SDavid Chisnall } while (__u >= _Rp); 30267a984708SDavid Chisnall return static_cast<result_type>(__u + __p.a()); 30277a984708SDavid Chisnall} 30287a984708SDavid Chisnall 30294f7ab58eSDimitry Andricclass _LIBCPP_TYPE_VIS __rs_default; 30307a984708SDavid Chisnall 30314f7ab58eSDimitry Andric_LIBCPP_FUNC_VIS __rs_default __rs_get(); 30327a984708SDavid Chisnall 30334f7ab58eSDimitry Andricclass _LIBCPP_TYPE_VIS __rs_default 30347a984708SDavid Chisnall{ 30357a984708SDavid Chisnall static unsigned __c_; 30367a984708SDavid Chisnall 30377a984708SDavid Chisnall __rs_default(); 30387a984708SDavid Chisnallpublic: 30391bf9f7c1SDimitry Andric typedef uint_fast32_t result_type; 30407a984708SDavid Chisnall 30417a984708SDavid Chisnall static const result_type _Min = 0; 30427a984708SDavid Chisnall static const result_type _Max = 0xFFFFFFFF; 30437a984708SDavid Chisnall 30447a984708SDavid Chisnall __rs_default(const __rs_default&); 30457a984708SDavid Chisnall ~__rs_default(); 30467a984708SDavid Chisnall 30477a984708SDavid Chisnall result_type operator()(); 30487a984708SDavid Chisnall 3049b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR result_type min() {return _Min;} 3050b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR result_type max() {return _Max;} 30517a984708SDavid Chisnall 30524f7ab58eSDimitry Andric friend _LIBCPP_FUNC_VIS __rs_default __rs_get(); 30537a984708SDavid Chisnall}; 30547a984708SDavid Chisnall 30554f7ab58eSDimitry Andric_LIBCPP_FUNC_VIS __rs_default __rs_get(); 30567a984708SDavid Chisnall 30577a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 30587a984708SDavid Chisnallvoid 30597a984708SDavid Chisnallrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) 30607a984708SDavid Chisnall{ 30617a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 306294e3ee44SDavid Chisnall typedef uniform_int_distribution<ptrdiff_t> _Dp; 306394e3ee44SDavid Chisnall typedef typename _Dp::param_type _Pp; 30647a984708SDavid Chisnall difference_type __d = __last - __first; 30657a984708SDavid Chisnall if (__d > 1) 30667a984708SDavid Chisnall { 306794e3ee44SDavid Chisnall _Dp __uid; 30687a984708SDavid Chisnall __rs_default __g = __rs_get(); 30697a984708SDavid Chisnall for (--__last, --__d; __first < __last; ++__first, --__d) 30707a984708SDavid Chisnall { 307194e3ee44SDavid Chisnall difference_type __i = __uid(__g, _Pp(0, __d)); 30727a984708SDavid Chisnall if (__i != difference_type(0)) 30737a984708SDavid Chisnall swap(*__first, *(__first + __i)); 30747a984708SDavid Chisnall } 30757a984708SDavid Chisnall } 30767a984708SDavid Chisnall} 30777a984708SDavid Chisnall 30787a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _RandomNumberGenerator> 30797a984708SDavid Chisnallvoid 30807a984708SDavid Chisnallrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 30817a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 30827a984708SDavid Chisnall _RandomNumberGenerator&& __rand) 30837a984708SDavid Chisnall#else 30847a984708SDavid Chisnall _RandomNumberGenerator& __rand) 30857a984708SDavid Chisnall#endif 30867a984708SDavid Chisnall{ 30877a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 30887a984708SDavid Chisnall difference_type __d = __last - __first; 30897a984708SDavid Chisnall if (__d > 1) 30907a984708SDavid Chisnall { 30917a984708SDavid Chisnall for (--__last; __first < __last; ++__first, --__d) 30927a984708SDavid Chisnall { 30937a984708SDavid Chisnall difference_type __i = __rand(__d); 30947a984708SDavid Chisnall swap(*__first, *(__first + __i)); 30957a984708SDavid Chisnall } 30967a984708SDavid Chisnall } 30977a984708SDavid Chisnall} 30987a984708SDavid Chisnall 3099aed8d94eSDimitry Andrictemplate <class _PopulationIterator, class _SampleIterator, class _Distance, 3100aed8d94eSDimitry Andric class _UniformRandomNumberGenerator> 3101aed8d94eSDimitry Andric_LIBCPP_INLINE_VISIBILITY 3102aed8d94eSDimitry Andric_SampleIterator __sample(_PopulationIterator __first, 310380779b37SDimitry Andric _PopulationIterator __last, _SampleIterator __output, 3104aed8d94eSDimitry Andric _Distance __n, 3105aed8d94eSDimitry Andric _UniformRandomNumberGenerator & __g, 3106aed8d94eSDimitry Andric input_iterator_tag) { 3107aed8d94eSDimitry Andric 3108aed8d94eSDimitry Andric _Distance __k = 0; 3109aed8d94eSDimitry Andric for (; __first != __last && __k < __n; ++__first, (void)++__k) 311080779b37SDimitry Andric __output[__k] = *__first; 3111aed8d94eSDimitry Andric _Distance __sz = __k; 3112aed8d94eSDimitry Andric for (; __first != __last; ++__first, (void)++__k) { 3113aed8d94eSDimitry Andric _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g); 3114aed8d94eSDimitry Andric if (__r < __sz) 311580779b37SDimitry Andric __output[__r] = *__first; 3116aed8d94eSDimitry Andric } 311780779b37SDimitry Andric return __output + _VSTD::min(__n, __k); 3118aed8d94eSDimitry Andric} 3119aed8d94eSDimitry Andric 3120aed8d94eSDimitry Andrictemplate <class _PopulationIterator, class _SampleIterator, class _Distance, 3121aed8d94eSDimitry Andric class _UniformRandomNumberGenerator> 3122aed8d94eSDimitry Andric_LIBCPP_INLINE_VISIBILITY 3123aed8d94eSDimitry Andric_SampleIterator __sample(_PopulationIterator __first, 312480779b37SDimitry Andric _PopulationIterator __last, _SampleIterator __output, 3125aed8d94eSDimitry Andric _Distance __n, 3126aed8d94eSDimitry Andric _UniformRandomNumberGenerator& __g, 3127aed8d94eSDimitry Andric forward_iterator_tag) { 3128aed8d94eSDimitry Andric _Distance __unsampled_sz = _VSTD::distance(__first, __last); 3129aed8d94eSDimitry Andric for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) { 3130aed8d94eSDimitry Andric _Distance __r = 3131aed8d94eSDimitry Andric _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g); 3132aed8d94eSDimitry Andric if (__r < __n) { 313380779b37SDimitry Andric *__output++ = *__first; 3134aed8d94eSDimitry Andric --__n; 3135aed8d94eSDimitry Andric } 3136aed8d94eSDimitry Andric } 313780779b37SDimitry Andric return __output; 3138aed8d94eSDimitry Andric} 3139aed8d94eSDimitry Andric 3140aed8d94eSDimitry Andrictemplate <class _PopulationIterator, class _SampleIterator, class _Distance, 3141aed8d94eSDimitry Andric class _UniformRandomNumberGenerator> 3142aed8d94eSDimitry Andric_LIBCPP_INLINE_VISIBILITY 3143aed8d94eSDimitry Andric_SampleIterator __sample(_PopulationIterator __first, 314480779b37SDimitry Andric _PopulationIterator __last, _SampleIterator __output, 3145aed8d94eSDimitry Andric _Distance __n, _UniformRandomNumberGenerator& __g) { 3146aed8d94eSDimitry Andric typedef typename iterator_traits<_PopulationIterator>::iterator_category 3147aed8d94eSDimitry Andric _PopCategory; 3148aed8d94eSDimitry Andric typedef typename iterator_traits<_PopulationIterator>::difference_type 3149aed8d94eSDimitry Andric _Difference; 3150aed8d94eSDimitry Andric static_assert(__is_forward_iterator<_PopulationIterator>::value || 3151aed8d94eSDimitry Andric __is_random_access_iterator<_SampleIterator>::value, 3152aed8d94eSDimitry Andric "SampleIterator must meet the requirements of RandomAccessIterator"); 3153aed8d94eSDimitry Andric typedef typename common_type<_Distance, _Difference>::type _CommonType; 3154aed8d94eSDimitry Andric _LIBCPP_ASSERT(__n >= 0, "N must be a positive number."); 3155aed8d94eSDimitry Andric return _VSTD::__sample( 315680779b37SDimitry Andric __first, __last, __output, _CommonType(__n), 3157aed8d94eSDimitry Andric __g, _PopCategory()); 3158aed8d94eSDimitry Andric} 3159aed8d94eSDimitry Andric 3160aed8d94eSDimitry Andric#if _LIBCPP_STD_VER > 14 3161aed8d94eSDimitry Andrictemplate <class _PopulationIterator, class _SampleIterator, class _Distance, 3162aed8d94eSDimitry Andric class _UniformRandomNumberGenerator> 3163aed8d94eSDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 3164aed8d94eSDimitry Andric_SampleIterator sample(_PopulationIterator __first, 316580779b37SDimitry Andric _PopulationIterator __last, _SampleIterator __output, 3166aed8d94eSDimitry Andric _Distance __n, _UniformRandomNumberGenerator&& __g) { 316780779b37SDimitry Andric return _VSTD::__sample(__first, __last, __output, __n, __g); 3168aed8d94eSDimitry Andric} 3169aed8d94eSDimitry Andric#endif // _LIBCPP_STD_VER > 14 3170aed8d94eSDimitry Andric 31717a984708SDavid Chisnalltemplate<class _RandomAccessIterator, class _UniformRandomNumberGenerator> 31727a984708SDavid Chisnall void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 31737a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 31747a984708SDavid Chisnall _UniformRandomNumberGenerator&& __g) 31757a984708SDavid Chisnall#else 31767a984708SDavid Chisnall _UniformRandomNumberGenerator& __g) 31777a984708SDavid Chisnall#endif 31787a984708SDavid Chisnall{ 31797a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 318094e3ee44SDavid Chisnall typedef uniform_int_distribution<ptrdiff_t> _Dp; 318194e3ee44SDavid Chisnall typedef typename _Dp::param_type _Pp; 31827a984708SDavid Chisnall difference_type __d = __last - __first; 31837a984708SDavid Chisnall if (__d > 1) 31847a984708SDavid Chisnall { 318594e3ee44SDavid Chisnall _Dp __uid; 31867a984708SDavid Chisnall for (--__last, --__d; __first < __last; ++__first, --__d) 31877a984708SDavid Chisnall { 318894e3ee44SDavid Chisnall difference_type __i = __uid(__g, _Pp(0, __d)); 31897a984708SDavid Chisnall if (__i != difference_type(0)) 31907a984708SDavid Chisnall swap(*__first, *(__first + __i)); 31917a984708SDavid Chisnall } 31927a984708SDavid Chisnall } 31937a984708SDavid Chisnall} 31947a984708SDavid Chisnall 31957a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 31967a984708SDavid Chisnallbool 31977a984708SDavid Chisnallis_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) 31987a984708SDavid Chisnall{ 31997a984708SDavid Chisnall for (; __first != __last; ++__first) 32007a984708SDavid Chisnall if (!__pred(*__first)) 32017a984708SDavid Chisnall break; 3202854fa44bSDimitry Andric if ( __first == __last ) 3203854fa44bSDimitry Andric return true; 3204854fa44bSDimitry Andric ++__first; 32057a984708SDavid Chisnall for (; __first != __last; ++__first) 32067a984708SDavid Chisnall if (__pred(*__first)) 32077a984708SDavid Chisnall return false; 32087a984708SDavid Chisnall return true; 32097a984708SDavid Chisnall} 32107a984708SDavid Chisnall 32117a984708SDavid Chisnall// partition 32127a984708SDavid Chisnall 32137a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator> 32147a984708SDavid Chisnall_ForwardIterator 32157a984708SDavid Chisnall__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) 32167a984708SDavid Chisnall{ 32177a984708SDavid Chisnall while (true) 32187a984708SDavid Chisnall { 32197a984708SDavid Chisnall if (__first == __last) 32207a984708SDavid Chisnall return __first; 32217a984708SDavid Chisnall if (!__pred(*__first)) 32227a984708SDavid Chisnall break; 32237a984708SDavid Chisnall ++__first; 32247a984708SDavid Chisnall } 32257a984708SDavid Chisnall for (_ForwardIterator __p = __first; ++__p != __last;) 32267a984708SDavid Chisnall { 32277a984708SDavid Chisnall if (__pred(*__p)) 32287a984708SDavid Chisnall { 32297a984708SDavid Chisnall swap(*__first, *__p); 32307a984708SDavid Chisnall ++__first; 32317a984708SDavid Chisnall } 32327a984708SDavid Chisnall } 32337a984708SDavid Chisnall return __first; 32347a984708SDavid Chisnall} 32357a984708SDavid Chisnall 32367a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator> 32377a984708SDavid Chisnall_BidirectionalIterator 32387a984708SDavid Chisnall__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 32397a984708SDavid Chisnall bidirectional_iterator_tag) 32407a984708SDavid Chisnall{ 32417a984708SDavid Chisnall while (true) 32427a984708SDavid Chisnall { 32437a984708SDavid Chisnall while (true) 32447a984708SDavid Chisnall { 32457a984708SDavid Chisnall if (__first == __last) 32467a984708SDavid Chisnall return __first; 32477a984708SDavid Chisnall if (!__pred(*__first)) 32487a984708SDavid Chisnall break; 32497a984708SDavid Chisnall ++__first; 32507a984708SDavid Chisnall } 32517a984708SDavid Chisnall do 32527a984708SDavid Chisnall { 32537a984708SDavid Chisnall if (__first == --__last) 32547a984708SDavid Chisnall return __first; 32557a984708SDavid Chisnall } while (!__pred(*__last)); 32567a984708SDavid Chisnall swap(*__first, *__last); 32577a984708SDavid Chisnall ++__first; 32587a984708SDavid Chisnall } 32597a984708SDavid Chisnall} 32607a984708SDavid Chisnall 32617a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate> 32627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 32637a984708SDavid Chisnall_ForwardIterator 32647a984708SDavid Chisnallpartition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 32657a984708SDavid Chisnall{ 32667a984708SDavid Chisnall return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type> 32677a984708SDavid Chisnall (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 32687a984708SDavid Chisnall} 32697a984708SDavid Chisnall 32707a984708SDavid Chisnall// partition_copy 32717a984708SDavid Chisnall 32727a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator1, 32737a984708SDavid Chisnall class _OutputIterator2, class _Predicate> 32747a984708SDavid Chisnallpair<_OutputIterator1, _OutputIterator2> 32757a984708SDavid Chisnallpartition_copy(_InputIterator __first, _InputIterator __last, 32767a984708SDavid Chisnall _OutputIterator1 __out_true, _OutputIterator2 __out_false, 32777a984708SDavid Chisnall _Predicate __pred) 32787a984708SDavid Chisnall{ 32797a984708SDavid Chisnall for (; __first != __last; ++__first) 32807a984708SDavid Chisnall { 32817a984708SDavid Chisnall if (__pred(*__first)) 32827a984708SDavid Chisnall { 32837a984708SDavid Chisnall *__out_true = *__first; 32847a984708SDavid Chisnall ++__out_true; 32857a984708SDavid Chisnall } 32867a984708SDavid Chisnall else 32877a984708SDavid Chisnall { 32887a984708SDavid Chisnall *__out_false = *__first; 32897a984708SDavid Chisnall ++__out_false; 32907a984708SDavid Chisnall } 32917a984708SDavid Chisnall } 32927a984708SDavid Chisnall return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); 32937a984708SDavid Chisnall} 32947a984708SDavid Chisnall 32957a984708SDavid Chisnall// partition_point 32967a984708SDavid Chisnall 32977a984708SDavid Chisnalltemplate<class _ForwardIterator, class _Predicate> 32987a984708SDavid Chisnall_ForwardIterator 32997a984708SDavid Chisnallpartition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 33007a984708SDavid Chisnall{ 33017a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 33027a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 33037a984708SDavid Chisnall while (__len != 0) 33047a984708SDavid Chisnall { 33057a984708SDavid Chisnall difference_type __l2 = __len / 2; 33067a984708SDavid Chisnall _ForwardIterator __m = __first; 33077a984708SDavid Chisnall _VSTD::advance(__m, __l2); 33087a984708SDavid Chisnall if (__pred(*__m)) 33097a984708SDavid Chisnall { 33107a984708SDavid Chisnall __first = ++__m; 33117a984708SDavid Chisnall __len -= __l2 + 1; 33127a984708SDavid Chisnall } 33137a984708SDavid Chisnall else 33147a984708SDavid Chisnall __len = __l2; 33157a984708SDavid Chisnall } 33167a984708SDavid Chisnall return __first; 33177a984708SDavid Chisnall} 33187a984708SDavid Chisnall 33197a984708SDavid Chisnall// stable_partition 33207a984708SDavid Chisnall 33217a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator, class _Distance, class _Pair> 33227a984708SDavid Chisnall_ForwardIterator 33237a984708SDavid Chisnall__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 33247a984708SDavid Chisnall _Distance __len, _Pair __p, forward_iterator_tag __fit) 33257a984708SDavid Chisnall{ 33267a984708SDavid Chisnall // *__first is known to be false 33277a984708SDavid Chisnall // __len >= 1 33287a984708SDavid Chisnall if (__len == 1) 33297a984708SDavid Chisnall return __first; 33307a984708SDavid Chisnall if (__len == 2) 33317a984708SDavid Chisnall { 33327a984708SDavid Chisnall _ForwardIterator __m = __first; 33337a984708SDavid Chisnall if (__pred(*++__m)) 33347a984708SDavid Chisnall { 33357a984708SDavid Chisnall swap(*__first, *__m); 33367a984708SDavid Chisnall return __m; 33377a984708SDavid Chisnall } 33387a984708SDavid Chisnall return __first; 33397a984708SDavid Chisnall } 33407a984708SDavid Chisnall if (__len <= __p.second) 33417a984708SDavid Chisnall { // The buffer is big enough to use 33427a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 33437a984708SDavid Chisnall __destruct_n __d(0); 33447a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 33457a984708SDavid Chisnall // Move the falses into the temporary buffer, and the trues to the front of the line 33467a984708SDavid Chisnall // Update __first to always point to the end of the trues 33477a984708SDavid Chisnall value_type* __t = __p.first; 33487a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__first)); 33497a984708SDavid Chisnall __d.__incr((value_type*)0); 33507a984708SDavid Chisnall ++__t; 33517a984708SDavid Chisnall _ForwardIterator __i = __first; 33527a984708SDavid Chisnall while (++__i != __last) 33537a984708SDavid Chisnall { 33547a984708SDavid Chisnall if (__pred(*__i)) 33557a984708SDavid Chisnall { 33567a984708SDavid Chisnall *__first = _VSTD::move(*__i); 33577a984708SDavid Chisnall ++__first; 33587a984708SDavid Chisnall } 33597a984708SDavid Chisnall else 33607a984708SDavid Chisnall { 33617a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__i)); 33627a984708SDavid Chisnall __d.__incr((value_type*)0); 33637a984708SDavid Chisnall ++__t; 33647a984708SDavid Chisnall } 33657a984708SDavid Chisnall } 33667a984708SDavid Chisnall // All trues now at start of range, all falses in buffer 33677a984708SDavid Chisnall // Move falses back into range, but don't mess up __first which points to first false 33687a984708SDavid Chisnall __i = __first; 33697a984708SDavid Chisnall for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 33707a984708SDavid Chisnall *__i = _VSTD::move(*__t2); 33717a984708SDavid Chisnall // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 33727a984708SDavid Chisnall return __first; 33737a984708SDavid Chisnall } 33747a984708SDavid Chisnall // Else not enough buffer, do in place 33757a984708SDavid Chisnall // __len >= 3 33767a984708SDavid Chisnall _ForwardIterator __m = __first; 33777a984708SDavid Chisnall _Distance __len2 = __len / 2; // __len2 >= 2 33787a984708SDavid Chisnall _VSTD::advance(__m, __len2); 33797a984708SDavid Chisnall // recurse on [__first, __m), *__first know to be false 33807a984708SDavid Chisnall // F????????????????? 33817a984708SDavid Chisnall // f m l 33827a984708SDavid Chisnall typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 33837a984708SDavid Chisnall _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit); 33847a984708SDavid Chisnall // TTTFFFFF?????????? 33857a984708SDavid Chisnall // f ff m l 33867a984708SDavid Chisnall // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 33877a984708SDavid Chisnall _ForwardIterator __m1 = __m; 33887a984708SDavid Chisnall _ForwardIterator __second_false = __last; 33897a984708SDavid Chisnall _Distance __len_half = __len - __len2; 33907a984708SDavid Chisnall while (__pred(*__m1)) 33917a984708SDavid Chisnall { 33927a984708SDavid Chisnall if (++__m1 == __last) 33937a984708SDavid Chisnall goto __second_half_done; 33947a984708SDavid Chisnall --__len_half; 33957a984708SDavid Chisnall } 33967a984708SDavid Chisnall // TTTFFFFFTTTF?????? 33977a984708SDavid Chisnall // f ff m m1 l 33987a984708SDavid Chisnall __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit); 33997a984708SDavid Chisnall__second_half_done: 34007a984708SDavid Chisnall // TTTFFFFFTTTTTFFFFF 34017a984708SDavid Chisnall // f ff m sf l 34027a984708SDavid Chisnall return _VSTD::rotate(__first_false, __m, __second_false); 34037a984708SDavid Chisnall // TTTTTTTTFFFFFFFFFF 34047a984708SDavid Chisnall // | 34057a984708SDavid Chisnall} 34067a984708SDavid Chisnall 34077a984708SDavid Chisnallstruct __return_temporary_buffer 34087a984708SDavid Chisnall{ 34097a984708SDavid Chisnall template <class _Tp> 34107a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);} 34117a984708SDavid Chisnall}; 34127a984708SDavid Chisnall 34137a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator> 34147a984708SDavid Chisnall_ForwardIterator 34157a984708SDavid Chisnall__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 34167a984708SDavid Chisnall forward_iterator_tag) 34177a984708SDavid Chisnall{ 34187a984708SDavid Chisnall const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment 34197a984708SDavid Chisnall // Either prove all true and return __first or point to first false 34207a984708SDavid Chisnall while (true) 34217a984708SDavid Chisnall { 34227a984708SDavid Chisnall if (__first == __last) 34237a984708SDavid Chisnall return __first; 34247a984708SDavid Chisnall if (!__pred(*__first)) 34257a984708SDavid Chisnall break; 34267a984708SDavid Chisnall ++__first; 34277a984708SDavid Chisnall } 34287a984708SDavid Chisnall // We now have a reduced range [__first, __last) 34297a984708SDavid Chisnall // *__first is known to be false 34307a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 34317a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 34327a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 34337a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __p(0, 0); 34347a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 34357a984708SDavid Chisnall if (__len >= __alloc_limit) 34367a984708SDavid Chisnall { 34377a984708SDavid Chisnall __p = _VSTD::get_temporary_buffer<value_type>(__len); 34387a984708SDavid Chisnall __h.reset(__p.first); 34397a984708SDavid Chisnall } 34407a984708SDavid Chisnall return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 34417a984708SDavid Chisnall (__first, __last, __pred, __len, __p, forward_iterator_tag()); 34427a984708SDavid Chisnall} 34437a984708SDavid Chisnall 34447a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair> 34457a984708SDavid Chisnall_BidirectionalIterator 34467a984708SDavid Chisnall__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 34477a984708SDavid Chisnall _Distance __len, _Pair __p, bidirectional_iterator_tag __bit) 34487a984708SDavid Chisnall{ 34497a984708SDavid Chisnall // *__first is known to be false 34507a984708SDavid Chisnall // *__last is known to be true 34517a984708SDavid Chisnall // __len >= 2 34527a984708SDavid Chisnall if (__len == 2) 34537a984708SDavid Chisnall { 34547a984708SDavid Chisnall swap(*__first, *__last); 34557a984708SDavid Chisnall return __last; 34567a984708SDavid Chisnall } 34577a984708SDavid Chisnall if (__len == 3) 34587a984708SDavid Chisnall { 34597a984708SDavid Chisnall _BidirectionalIterator __m = __first; 34607a984708SDavid Chisnall if (__pred(*++__m)) 34617a984708SDavid Chisnall { 34627a984708SDavid Chisnall swap(*__first, *__m); 34637a984708SDavid Chisnall swap(*__m, *__last); 34647a984708SDavid Chisnall return __last; 34657a984708SDavid Chisnall } 34667a984708SDavid Chisnall swap(*__m, *__last); 34677a984708SDavid Chisnall swap(*__first, *__m); 34687a984708SDavid Chisnall return __m; 34697a984708SDavid Chisnall } 34707a984708SDavid Chisnall if (__len <= __p.second) 34717a984708SDavid Chisnall { // The buffer is big enough to use 34727a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 34737a984708SDavid Chisnall __destruct_n __d(0); 34747a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 34757a984708SDavid Chisnall // Move the falses into the temporary buffer, and the trues to the front of the line 34767a984708SDavid Chisnall // Update __first to always point to the end of the trues 34777a984708SDavid Chisnall value_type* __t = __p.first; 34787a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__first)); 34797a984708SDavid Chisnall __d.__incr((value_type*)0); 34807a984708SDavid Chisnall ++__t; 34817a984708SDavid Chisnall _BidirectionalIterator __i = __first; 34827a984708SDavid Chisnall while (++__i != __last) 34837a984708SDavid Chisnall { 34847a984708SDavid Chisnall if (__pred(*__i)) 34857a984708SDavid Chisnall { 34867a984708SDavid Chisnall *__first = _VSTD::move(*__i); 34877a984708SDavid Chisnall ++__first; 34887a984708SDavid Chisnall } 34897a984708SDavid Chisnall else 34907a984708SDavid Chisnall { 34917a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__i)); 34927a984708SDavid Chisnall __d.__incr((value_type*)0); 34937a984708SDavid Chisnall ++__t; 34947a984708SDavid Chisnall } 34957a984708SDavid Chisnall } 34967a984708SDavid Chisnall // move *__last, known to be true 34977a984708SDavid Chisnall *__first = _VSTD::move(*__i); 34987a984708SDavid Chisnall __i = ++__first; 34997a984708SDavid Chisnall // All trues now at start of range, all falses in buffer 35007a984708SDavid Chisnall // Move falses back into range, but don't mess up __first which points to first false 35017a984708SDavid Chisnall for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 35027a984708SDavid Chisnall *__i = _VSTD::move(*__t2); 35037a984708SDavid Chisnall // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 35047a984708SDavid Chisnall return __first; 35057a984708SDavid Chisnall } 35067a984708SDavid Chisnall // Else not enough buffer, do in place 35077a984708SDavid Chisnall // __len >= 4 35087a984708SDavid Chisnall _BidirectionalIterator __m = __first; 35097a984708SDavid Chisnall _Distance __len2 = __len / 2; // __len2 >= 2 35107a984708SDavid Chisnall _VSTD::advance(__m, __len2); 35117a984708SDavid Chisnall // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false 35127a984708SDavid Chisnall // F????????????????T 35137a984708SDavid Chisnall // f m l 35147a984708SDavid Chisnall _BidirectionalIterator __m1 = __m; 35157a984708SDavid Chisnall _BidirectionalIterator __first_false = __first; 35167a984708SDavid Chisnall _Distance __len_half = __len2; 35177a984708SDavid Chisnall while (!__pred(*--__m1)) 35187a984708SDavid Chisnall { 35197a984708SDavid Chisnall if (__m1 == __first) 35207a984708SDavid Chisnall goto __first_half_done; 35217a984708SDavid Chisnall --__len_half; 35227a984708SDavid Chisnall } 35237a984708SDavid Chisnall // F???TFFF?????????T 35247a984708SDavid Chisnall // f m1 m l 35257a984708SDavid Chisnall typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 35267a984708SDavid Chisnall __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit); 35277a984708SDavid Chisnall__first_half_done: 35287a984708SDavid Chisnall // TTTFFFFF?????????T 35297a984708SDavid Chisnall // f ff m l 35307a984708SDavid Chisnall // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 35317a984708SDavid Chisnall __m1 = __m; 35327a984708SDavid Chisnall _BidirectionalIterator __second_false = __last; 35337a984708SDavid Chisnall ++__second_false; 35347a984708SDavid Chisnall __len_half = __len - __len2; 35357a984708SDavid Chisnall while (__pred(*__m1)) 35367a984708SDavid Chisnall { 35377a984708SDavid Chisnall if (++__m1 == __last) 35387a984708SDavid Chisnall goto __second_half_done; 35397a984708SDavid Chisnall --__len_half; 35407a984708SDavid Chisnall } 35417a984708SDavid Chisnall // TTTFFFFFTTTF?????T 35427a984708SDavid Chisnall // f ff m m1 l 35437a984708SDavid Chisnall __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit); 35447a984708SDavid Chisnall__second_half_done: 35457a984708SDavid Chisnall // TTTFFFFFTTTTTFFFFF 35467a984708SDavid Chisnall // f ff m sf l 35477a984708SDavid Chisnall return _VSTD::rotate(__first_false, __m, __second_false); 35487a984708SDavid Chisnall // TTTTTTTTFFFFFFFFFF 35497a984708SDavid Chisnall // | 35507a984708SDavid Chisnall} 35517a984708SDavid Chisnall 35527a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator> 35537a984708SDavid Chisnall_BidirectionalIterator 35547a984708SDavid Chisnall__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 35557a984708SDavid Chisnall bidirectional_iterator_tag) 35567a984708SDavid Chisnall{ 35577a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 35587a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 35597a984708SDavid Chisnall const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment 35607a984708SDavid Chisnall // Either prove all true and return __first or point to first false 35617a984708SDavid Chisnall while (true) 35627a984708SDavid Chisnall { 35637a984708SDavid Chisnall if (__first == __last) 35647a984708SDavid Chisnall return __first; 35657a984708SDavid Chisnall if (!__pred(*__first)) 35667a984708SDavid Chisnall break; 35677a984708SDavid Chisnall ++__first; 35687a984708SDavid Chisnall } 35697a984708SDavid Chisnall // __first points to first false, everything prior to __first is already set. 35707a984708SDavid Chisnall // Either prove [__first, __last) is all false and return __first, or point __last to last true 35717a984708SDavid Chisnall do 35727a984708SDavid Chisnall { 35737a984708SDavid Chisnall if (__first == --__last) 35747a984708SDavid Chisnall return __first; 35757a984708SDavid Chisnall } while (!__pred(*__last)); 35767a984708SDavid Chisnall // We now have a reduced range [__first, __last] 35777a984708SDavid Chisnall // *__first is known to be false 35787a984708SDavid Chisnall // *__last is known to be true 35797a984708SDavid Chisnall // __len >= 2 35807a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last) + 1; 35817a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __p(0, 0); 35827a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 35837a984708SDavid Chisnall if (__len >= __alloc_limit) 35847a984708SDavid Chisnall { 35857a984708SDavid Chisnall __p = _VSTD::get_temporary_buffer<value_type>(__len); 35867a984708SDavid Chisnall __h.reset(__p.first); 35877a984708SDavid Chisnall } 35887a984708SDavid Chisnall return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 35897a984708SDavid Chisnall (__first, __last, __pred, __len, __p, bidirectional_iterator_tag()); 35907a984708SDavid Chisnall} 35917a984708SDavid Chisnall 35927a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate> 35937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 35947a984708SDavid Chisnall_ForwardIterator 35957a984708SDavid Chisnallstable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 35967a984708SDavid Chisnall{ 35977a984708SDavid Chisnall return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 35987a984708SDavid Chisnall (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 35997a984708SDavid Chisnall} 36007a984708SDavid Chisnall 36017a984708SDavid Chisnall// is_sorted_until 36027a984708SDavid Chisnall 36037a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 36047a984708SDavid Chisnall_ForwardIterator 36057a984708SDavid Chisnallis_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 36067a984708SDavid Chisnall{ 36077a984708SDavid Chisnall if (__first != __last) 36087a984708SDavid Chisnall { 36097a984708SDavid Chisnall _ForwardIterator __i = __first; 36107a984708SDavid Chisnall while (++__i != __last) 36117a984708SDavid Chisnall { 36127a984708SDavid Chisnall if (__comp(*__i, *__first)) 36137a984708SDavid Chisnall return __i; 36147a984708SDavid Chisnall __first = __i; 36157a984708SDavid Chisnall } 36167a984708SDavid Chisnall } 36177a984708SDavid Chisnall return __last; 36187a984708SDavid Chisnall} 36197a984708SDavid Chisnall 36207a984708SDavid Chisnalltemplate<class _ForwardIterator> 36217a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 36227a984708SDavid Chisnall_ForwardIterator 36237a984708SDavid Chisnallis_sorted_until(_ForwardIterator __first, _ForwardIterator __last) 36247a984708SDavid Chisnall{ 36257a984708SDavid Chisnall return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 36267a984708SDavid Chisnall} 36277a984708SDavid Chisnall 36287a984708SDavid Chisnall// is_sorted 36297a984708SDavid Chisnall 36307a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 36317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 36327a984708SDavid Chisnallbool 36337a984708SDavid Chisnallis_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 36347a984708SDavid Chisnall{ 36357a984708SDavid Chisnall return _VSTD::is_sorted_until(__first, __last, __comp) == __last; 36367a984708SDavid Chisnall} 36377a984708SDavid Chisnall 36387a984708SDavid Chisnalltemplate<class _ForwardIterator> 36397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 36407a984708SDavid Chisnallbool 36417a984708SDavid Chisnallis_sorted(_ForwardIterator __first, _ForwardIterator __last) 36427a984708SDavid Chisnall{ 36437a984708SDavid Chisnall return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 36447a984708SDavid Chisnall} 36457a984708SDavid Chisnall 36467a984708SDavid Chisnall// sort 36477a984708SDavid Chisnall 36487a984708SDavid Chisnall// stable, 2-3 compares, 0-2 swaps 36497a984708SDavid Chisnall 36507a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator> 36517a984708SDavid Chisnallunsigned 36527a984708SDavid Chisnall__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c) 36537a984708SDavid Chisnall{ 36547a984708SDavid Chisnall unsigned __r = 0; 36557a984708SDavid Chisnall if (!__c(*__y, *__x)) // if x <= y 36567a984708SDavid Chisnall { 36577a984708SDavid Chisnall if (!__c(*__z, *__y)) // if y <= z 36587a984708SDavid Chisnall return __r; // x <= y && y <= z 36597a984708SDavid Chisnall // x <= y && y > z 36607a984708SDavid Chisnall swap(*__y, *__z); // x <= z && y < z 36617a984708SDavid Chisnall __r = 1; 36627a984708SDavid Chisnall if (__c(*__y, *__x)) // if x > y 36637a984708SDavid Chisnall { 36647a984708SDavid Chisnall swap(*__x, *__y); // x < y && y <= z 36657a984708SDavid Chisnall __r = 2; 36667a984708SDavid Chisnall } 36677a984708SDavid Chisnall return __r; // x <= y && y < z 36687a984708SDavid Chisnall } 36697a984708SDavid Chisnall if (__c(*__z, *__y)) // x > y, if y > z 36707a984708SDavid Chisnall { 36717a984708SDavid Chisnall swap(*__x, *__z); // x < y && y < z 36727a984708SDavid Chisnall __r = 1; 36737a984708SDavid Chisnall return __r; 36747a984708SDavid Chisnall } 36757a984708SDavid Chisnall swap(*__x, *__y); // x > y && y <= z 36767a984708SDavid Chisnall __r = 1; // x < y && x <= z 36777a984708SDavid Chisnall if (__c(*__z, *__y)) // if y > z 36787a984708SDavid Chisnall { 36797a984708SDavid Chisnall swap(*__y, *__z); // x <= y && y < z 36807a984708SDavid Chisnall __r = 2; 36817a984708SDavid Chisnall } 36827a984708SDavid Chisnall return __r; 36837a984708SDavid Chisnall} // x <= y && y <= z 36847a984708SDavid Chisnall 36857a984708SDavid Chisnall// stable, 3-6 compares, 0-5 swaps 36867a984708SDavid Chisnall 36877a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator> 36887a984708SDavid Chisnallunsigned 36897a984708SDavid Chisnall__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 36907a984708SDavid Chisnall _ForwardIterator __x4, _Compare __c) 36917a984708SDavid Chisnall{ 36927a984708SDavid Chisnall unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c); 36937a984708SDavid Chisnall if (__c(*__x4, *__x3)) 36947a984708SDavid Chisnall { 36957a984708SDavid Chisnall swap(*__x3, *__x4); 36967a984708SDavid Chisnall ++__r; 36977a984708SDavid Chisnall if (__c(*__x3, *__x2)) 36987a984708SDavid Chisnall { 36997a984708SDavid Chisnall swap(*__x2, *__x3); 37007a984708SDavid Chisnall ++__r; 37017a984708SDavid Chisnall if (__c(*__x2, *__x1)) 37027a984708SDavid Chisnall { 37037a984708SDavid Chisnall swap(*__x1, *__x2); 37047a984708SDavid Chisnall ++__r; 37057a984708SDavid Chisnall } 37067a984708SDavid Chisnall } 37077a984708SDavid Chisnall } 37087a984708SDavid Chisnall return __r; 37097a984708SDavid Chisnall} 37107a984708SDavid Chisnall 37117a984708SDavid Chisnall// stable, 4-10 compares, 0-9 swaps 37127a984708SDavid Chisnall 37137a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator> 37147a984708SDavid Chisnallunsigned 37157a984708SDavid Chisnall__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 37167a984708SDavid Chisnall _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c) 37177a984708SDavid Chisnall{ 37187a984708SDavid Chisnall unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c); 37197a984708SDavid Chisnall if (__c(*__x5, *__x4)) 37207a984708SDavid Chisnall { 37217a984708SDavid Chisnall swap(*__x4, *__x5); 37227a984708SDavid Chisnall ++__r; 37237a984708SDavid Chisnall if (__c(*__x4, *__x3)) 37247a984708SDavid Chisnall { 37257a984708SDavid Chisnall swap(*__x3, *__x4); 37267a984708SDavid Chisnall ++__r; 37277a984708SDavid Chisnall if (__c(*__x3, *__x2)) 37287a984708SDavid Chisnall { 37297a984708SDavid Chisnall swap(*__x2, *__x3); 37307a984708SDavid Chisnall ++__r; 37317a984708SDavid Chisnall if (__c(*__x2, *__x1)) 37327a984708SDavid Chisnall { 37337a984708SDavid Chisnall swap(*__x1, *__x2); 37347a984708SDavid Chisnall ++__r; 37357a984708SDavid Chisnall } 37367a984708SDavid Chisnall } 37377a984708SDavid Chisnall } 37387a984708SDavid Chisnall } 37397a984708SDavid Chisnall return __r; 37407a984708SDavid Chisnall} 37417a984708SDavid Chisnall 37427a984708SDavid Chisnall// Assumes size > 0 37437a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator> 37447a984708SDavid Chisnallvoid 37457a984708SDavid Chisnall__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 37467a984708SDavid Chisnall{ 37477a984708SDavid Chisnall _BirdirectionalIterator __lm1 = __last; 37487a984708SDavid Chisnall for (--__lm1; __first != __lm1; ++__first) 37497a984708SDavid Chisnall { 37507a984708SDavid Chisnall _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator, 37517a984708SDavid Chisnall typename add_lvalue_reference<_Compare>::type> 37527a984708SDavid Chisnall (__first, __last, __comp); 37537a984708SDavid Chisnall if (__i != __first) 37547a984708SDavid Chisnall swap(*__first, *__i); 37557a984708SDavid Chisnall } 37567a984708SDavid Chisnall} 37577a984708SDavid Chisnall 37587a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator> 37597a984708SDavid Chisnallvoid 37607a984708SDavid Chisnall__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 37617a984708SDavid Chisnall{ 37627a984708SDavid Chisnall typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 37637a984708SDavid Chisnall if (__first != __last) 37647a984708SDavid Chisnall { 37657a984708SDavid Chisnall _BirdirectionalIterator __i = __first; 37667a984708SDavid Chisnall for (++__i; __i != __last; ++__i) 37677a984708SDavid Chisnall { 37687a984708SDavid Chisnall _BirdirectionalIterator __j = __i; 37697a984708SDavid Chisnall value_type __t(_VSTD::move(*__j)); 37707a984708SDavid Chisnall for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j) 37717a984708SDavid Chisnall *__j = _VSTD::move(*__k); 37727a984708SDavid Chisnall *__j = _VSTD::move(__t); 37737a984708SDavid Chisnall } 37747a984708SDavid Chisnall } 37757a984708SDavid Chisnall} 37767a984708SDavid Chisnall 37777a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 37787a984708SDavid Chisnallvoid 37797a984708SDavid Chisnall__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 37807a984708SDavid Chisnall{ 37817a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 37827a984708SDavid Chisnall _RandomAccessIterator __j = __first+2; 37837a984708SDavid Chisnall __sort3<_Compare>(__first, __first+1, __j, __comp); 37847a984708SDavid Chisnall for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 37857a984708SDavid Chisnall { 37867a984708SDavid Chisnall if (__comp(*__i, *__j)) 37877a984708SDavid Chisnall { 37887a984708SDavid Chisnall value_type __t(_VSTD::move(*__i)); 37897a984708SDavid Chisnall _RandomAccessIterator __k = __j; 37907a984708SDavid Chisnall __j = __i; 37917a984708SDavid Chisnall do 37927a984708SDavid Chisnall { 37937a984708SDavid Chisnall *__j = _VSTD::move(*__k); 37947a984708SDavid Chisnall __j = __k; 37957a984708SDavid Chisnall } while (__j != __first && __comp(__t, *--__k)); 37967a984708SDavid Chisnall *__j = _VSTD::move(__t); 37977a984708SDavid Chisnall } 37987a984708SDavid Chisnall __j = __i; 37997a984708SDavid Chisnall } 38007a984708SDavid Chisnall} 38017a984708SDavid Chisnall 38027a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 38037a984708SDavid Chisnallbool 38047a984708SDavid Chisnall__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 38057a984708SDavid Chisnall{ 38067a984708SDavid Chisnall switch (__last - __first) 38077a984708SDavid Chisnall { 38087a984708SDavid Chisnall case 0: 38097a984708SDavid Chisnall case 1: 38107a984708SDavid Chisnall return true; 38117a984708SDavid Chisnall case 2: 38127a984708SDavid Chisnall if (__comp(*--__last, *__first)) 38137a984708SDavid Chisnall swap(*__first, *__last); 38147a984708SDavid Chisnall return true; 38157a984708SDavid Chisnall case 3: 38167a984708SDavid Chisnall _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 38177a984708SDavid Chisnall return true; 38187a984708SDavid Chisnall case 4: 38197a984708SDavid Chisnall _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 38207a984708SDavid Chisnall return true; 38217a984708SDavid Chisnall case 5: 38227a984708SDavid Chisnall _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 38237a984708SDavid Chisnall return true; 38247a984708SDavid Chisnall } 38257a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 38267a984708SDavid Chisnall _RandomAccessIterator __j = __first+2; 38277a984708SDavid Chisnall __sort3<_Compare>(__first, __first+1, __j, __comp); 38287a984708SDavid Chisnall const unsigned __limit = 8; 38297a984708SDavid Chisnall unsigned __count = 0; 38307a984708SDavid Chisnall for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 38317a984708SDavid Chisnall { 38327a984708SDavid Chisnall if (__comp(*__i, *__j)) 38337a984708SDavid Chisnall { 38347a984708SDavid Chisnall value_type __t(_VSTD::move(*__i)); 38357a984708SDavid Chisnall _RandomAccessIterator __k = __j; 38367a984708SDavid Chisnall __j = __i; 38377a984708SDavid Chisnall do 38387a984708SDavid Chisnall { 38397a984708SDavid Chisnall *__j = _VSTD::move(*__k); 38407a984708SDavid Chisnall __j = __k; 38417a984708SDavid Chisnall } while (__j != __first && __comp(__t, *--__k)); 38427a984708SDavid Chisnall *__j = _VSTD::move(__t); 38437a984708SDavid Chisnall if (++__count == __limit) 38447a984708SDavid Chisnall return ++__i == __last; 38457a984708SDavid Chisnall } 38467a984708SDavid Chisnall __j = __i; 38477a984708SDavid Chisnall } 38487a984708SDavid Chisnall return true; 38497a984708SDavid Chisnall} 38507a984708SDavid Chisnall 38517a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator> 38527a984708SDavid Chisnallvoid 38537a984708SDavid Chisnall__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1, 38547a984708SDavid Chisnall typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp) 38557a984708SDavid Chisnall{ 38567a984708SDavid Chisnall typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 38577a984708SDavid Chisnall if (__first1 != __last1) 38587a984708SDavid Chisnall { 38597a984708SDavid Chisnall __destruct_n __d(0); 38607a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__first2, __d); 38617a984708SDavid Chisnall value_type* __last2 = __first2; 38627a984708SDavid Chisnall ::new(__last2) value_type(_VSTD::move(*__first1)); 38637a984708SDavid Chisnall __d.__incr((value_type*)0); 38647a984708SDavid Chisnall for (++__last2; ++__first1 != __last1; ++__last2) 38657a984708SDavid Chisnall { 38667a984708SDavid Chisnall value_type* __j2 = __last2; 38677a984708SDavid Chisnall value_type* __i2 = __j2; 38687a984708SDavid Chisnall if (__comp(*__first1, *--__i2)) 38697a984708SDavid Chisnall { 38707a984708SDavid Chisnall ::new(__j2) value_type(_VSTD::move(*__i2)); 38717a984708SDavid Chisnall __d.__incr((value_type*)0); 38727a984708SDavid Chisnall for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2) 38737a984708SDavid Chisnall *__j2 = _VSTD::move(*__i2); 38747a984708SDavid Chisnall *__j2 = _VSTD::move(*__first1); 38757a984708SDavid Chisnall } 38767a984708SDavid Chisnall else 38777a984708SDavid Chisnall { 38787a984708SDavid Chisnall ::new(__j2) value_type(_VSTD::move(*__first1)); 38797a984708SDavid Chisnall __d.__incr((value_type*)0); 38807a984708SDavid Chisnall } 38817a984708SDavid Chisnall } 38827a984708SDavid Chisnall __h.release(); 38837a984708SDavid Chisnall } 38847a984708SDavid Chisnall} 38857a984708SDavid Chisnall 38867a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 38877a984708SDavid Chisnallvoid 38887a984708SDavid Chisnall__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 38897a984708SDavid Chisnall{ 38907a984708SDavid Chisnall // _Compare is known to be a reference type 38917a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 38927a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 38937a984708SDavid Chisnall const difference_type __limit = is_trivially_copy_constructible<value_type>::value && 38947a984708SDavid Chisnall is_trivially_copy_assignable<value_type>::value ? 30 : 6; 38957a984708SDavid Chisnall while (true) 38967a984708SDavid Chisnall { 38977a984708SDavid Chisnall __restart: 38987a984708SDavid Chisnall difference_type __len = __last - __first; 38997a984708SDavid Chisnall switch (__len) 39007a984708SDavid Chisnall { 39017a984708SDavid Chisnall case 0: 39027a984708SDavid Chisnall case 1: 39037a984708SDavid Chisnall return; 39047a984708SDavid Chisnall case 2: 39057a984708SDavid Chisnall if (__comp(*--__last, *__first)) 39067a984708SDavid Chisnall swap(*__first, *__last); 39077a984708SDavid Chisnall return; 39087a984708SDavid Chisnall case 3: 39097a984708SDavid Chisnall _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 39107a984708SDavid Chisnall return; 39117a984708SDavid Chisnall case 4: 39127a984708SDavid Chisnall _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 39137a984708SDavid Chisnall return; 39147a984708SDavid Chisnall case 5: 39157a984708SDavid Chisnall _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 39167a984708SDavid Chisnall return; 39177a984708SDavid Chisnall } 39187a984708SDavid Chisnall if (__len <= __limit) 39197a984708SDavid Chisnall { 39207a984708SDavid Chisnall _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp); 39217a984708SDavid Chisnall return; 39227a984708SDavid Chisnall } 39237a984708SDavid Chisnall // __len > 5 39247a984708SDavid Chisnall _RandomAccessIterator __m = __first; 39257a984708SDavid Chisnall _RandomAccessIterator __lm1 = __last; 39267a984708SDavid Chisnall --__lm1; 39277a984708SDavid Chisnall unsigned __n_swaps; 39287a984708SDavid Chisnall { 39297a984708SDavid Chisnall difference_type __delta; 39307a984708SDavid Chisnall if (__len >= 1000) 39317a984708SDavid Chisnall { 39327a984708SDavid Chisnall __delta = __len/2; 39337a984708SDavid Chisnall __m += __delta; 39347a984708SDavid Chisnall __delta /= 2; 39357a984708SDavid Chisnall __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp); 39367a984708SDavid Chisnall } 39377a984708SDavid Chisnall else 39387a984708SDavid Chisnall { 39397a984708SDavid Chisnall __delta = __len/2; 39407a984708SDavid Chisnall __m += __delta; 39417a984708SDavid Chisnall __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp); 39427a984708SDavid Chisnall } 39437a984708SDavid Chisnall } 39447a984708SDavid Chisnall // *__m is median 39457a984708SDavid Chisnall // partition [__first, __m) < *__m and *__m <= [__m, __last) 39467a984708SDavid Chisnall // (this inhibits tossing elements equivalent to __m around unnecessarily) 39477a984708SDavid Chisnall _RandomAccessIterator __i = __first; 39487a984708SDavid Chisnall _RandomAccessIterator __j = __lm1; 39497a984708SDavid Chisnall // j points beyond range to be tested, *__m is known to be <= *__lm1 39507a984708SDavid Chisnall // The search going up is known to be guarded but the search coming down isn't. 39517a984708SDavid Chisnall // Prime the downward search with a guard. 39527a984708SDavid Chisnall if (!__comp(*__i, *__m)) // if *__first == *__m 39537a984708SDavid Chisnall { 39547a984708SDavid Chisnall // *__first == *__m, *__first doesn't go in first part 39557a984708SDavid Chisnall // manually guard downward moving __j against __i 39567a984708SDavid Chisnall while (true) 39577a984708SDavid Chisnall { 39587a984708SDavid Chisnall if (__i == --__j) 39597a984708SDavid Chisnall { 39607a984708SDavid Chisnall // *__first == *__m, *__m <= all other elements 39617a984708SDavid Chisnall // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 39627a984708SDavid Chisnall ++__i; // __first + 1 39637a984708SDavid Chisnall __j = __last; 39647a984708SDavid Chisnall if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 39657a984708SDavid Chisnall { 39667a984708SDavid Chisnall while (true) 39677a984708SDavid Chisnall { 39687a984708SDavid Chisnall if (__i == __j) 39697a984708SDavid Chisnall return; // [__first, __last) all equivalent elements 39707a984708SDavid Chisnall if (__comp(*__first, *__i)) 39717a984708SDavid Chisnall { 39727a984708SDavid Chisnall swap(*__i, *__j); 39737a984708SDavid Chisnall ++__n_swaps; 39747a984708SDavid Chisnall ++__i; 39757a984708SDavid Chisnall break; 39767a984708SDavid Chisnall } 39777a984708SDavid Chisnall ++__i; 39787a984708SDavid Chisnall } 39797a984708SDavid Chisnall } 39807a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 39817a984708SDavid Chisnall if (__i == __j) 39827a984708SDavid Chisnall return; 39837a984708SDavid Chisnall while (true) 39847a984708SDavid Chisnall { 39857a984708SDavid Chisnall while (!__comp(*__first, *__i)) 39867a984708SDavid Chisnall ++__i; 39877a984708SDavid Chisnall while (__comp(*__first, *--__j)) 39887a984708SDavid Chisnall ; 39897a984708SDavid Chisnall if (__i >= __j) 39907a984708SDavid Chisnall break; 39917a984708SDavid Chisnall swap(*__i, *__j); 39927a984708SDavid Chisnall ++__n_swaps; 39937a984708SDavid Chisnall ++__i; 39947a984708SDavid Chisnall } 39957a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__i, __last) 39967a984708SDavid Chisnall // The first part is sorted, sort the secod part 39977a984708SDavid Chisnall // _VSTD::__sort<_Compare>(__i, __last, __comp); 39987a984708SDavid Chisnall __first = __i; 39997a984708SDavid Chisnall goto __restart; 40007a984708SDavid Chisnall } 40017a984708SDavid Chisnall if (__comp(*__j, *__m)) 40027a984708SDavid Chisnall { 40037a984708SDavid Chisnall swap(*__i, *__j); 40047a984708SDavid Chisnall ++__n_swaps; 40057a984708SDavid Chisnall break; // found guard for downward moving __j, now use unguarded partition 40067a984708SDavid Chisnall } 40077a984708SDavid Chisnall } 40087a984708SDavid Chisnall } 40097a984708SDavid Chisnall // It is known that *__i < *__m 40107a984708SDavid Chisnall ++__i; 40117a984708SDavid Chisnall // j points beyond range to be tested, *__m is known to be <= *__lm1 40127a984708SDavid Chisnall // if not yet partitioned... 40137a984708SDavid Chisnall if (__i < __j) 40147a984708SDavid Chisnall { 40157a984708SDavid Chisnall // known that *(__i - 1) < *__m 40167a984708SDavid Chisnall // known that __i <= __m 40177a984708SDavid Chisnall while (true) 40187a984708SDavid Chisnall { 40197a984708SDavid Chisnall // __m still guards upward moving __i 40207a984708SDavid Chisnall while (__comp(*__i, *__m)) 40217a984708SDavid Chisnall ++__i; 40227a984708SDavid Chisnall // It is now known that a guard exists for downward moving __j 40237a984708SDavid Chisnall while (!__comp(*--__j, *__m)) 40247a984708SDavid Chisnall ; 40257a984708SDavid Chisnall if (__i > __j) 40267a984708SDavid Chisnall break; 40277a984708SDavid Chisnall swap(*__i, *__j); 40287a984708SDavid Chisnall ++__n_swaps; 40297a984708SDavid Chisnall // It is known that __m != __j 40307a984708SDavid Chisnall // If __m just moved, follow it 40317a984708SDavid Chisnall if (__m == __i) 40327a984708SDavid Chisnall __m = __j; 40337a984708SDavid Chisnall ++__i; 40347a984708SDavid Chisnall } 40357a984708SDavid Chisnall } 40367a984708SDavid Chisnall // [__first, __i) < *__m and *__m <= [__i, __last) 40377a984708SDavid Chisnall if (__i != __m && __comp(*__m, *__i)) 40387a984708SDavid Chisnall { 40397a984708SDavid Chisnall swap(*__i, *__m); 40407a984708SDavid Chisnall ++__n_swaps; 40417a984708SDavid Chisnall } 40427a984708SDavid Chisnall // [__first, __i) < *__i and *__i <= [__i+1, __last) 40437a984708SDavid Chisnall // If we were given a perfect partition, see if insertion sort is quick... 40447a984708SDavid Chisnall if (__n_swaps == 0) 40457a984708SDavid Chisnall { 40467a984708SDavid Chisnall bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp); 40477a984708SDavid Chisnall if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp)) 40487a984708SDavid Chisnall { 40497a984708SDavid Chisnall if (__fs) 40507a984708SDavid Chisnall return; 40517a984708SDavid Chisnall __last = __i; 40527a984708SDavid Chisnall continue; 40537a984708SDavid Chisnall } 40547a984708SDavid Chisnall else 40557a984708SDavid Chisnall { 40567a984708SDavid Chisnall if (__fs) 40577a984708SDavid Chisnall { 40587a984708SDavid Chisnall __first = ++__i; 40597a984708SDavid Chisnall continue; 40607a984708SDavid Chisnall } 40617a984708SDavid Chisnall } 40627a984708SDavid Chisnall } 40637a984708SDavid Chisnall // sort smaller range with recursive call and larger with tail recursion elimination 40647a984708SDavid Chisnall if (__i - __first < __last - __i) 40657a984708SDavid Chisnall { 40667a984708SDavid Chisnall _VSTD::__sort<_Compare>(__first, __i, __comp); 40677a984708SDavid Chisnall // _VSTD::__sort<_Compare>(__i+1, __last, __comp); 40687a984708SDavid Chisnall __first = ++__i; 40697a984708SDavid Chisnall } 40707a984708SDavid Chisnall else 40717a984708SDavid Chisnall { 40727a984708SDavid Chisnall _VSTD::__sort<_Compare>(__i+1, __last, __comp); 40737a984708SDavid Chisnall // _VSTD::__sort<_Compare>(__first, __i, __comp); 40747a984708SDavid Chisnall __last = __i; 40757a984708SDavid Chisnall } 40767a984708SDavid Chisnall } 40777a984708SDavid Chisnall} 40787a984708SDavid Chisnall 40797a984708SDavid Chisnall// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare 40807a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 40817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 40827a984708SDavid Chisnallvoid 40837a984708SDavid Chisnallsort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 40847a984708SDavid Chisnall{ 40854f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 40867a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 40877a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 40887a984708SDavid Chisnall __sort<_Comp_ref>(__first, __last, __c); 40894f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 40907a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 40917a984708SDavid Chisnall __sort<_Comp_ref>(__first, __last, __comp); 40924f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 40937a984708SDavid Chisnall} 40947a984708SDavid Chisnall 40957a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 40967a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 40977a984708SDavid Chisnallvoid 40987a984708SDavid Chisnallsort(_RandomAccessIterator __first, _RandomAccessIterator __last) 40997a984708SDavid Chisnall{ 41007a984708SDavid Chisnall _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 41017a984708SDavid Chisnall} 41027a984708SDavid Chisnall 41037a984708SDavid Chisnalltemplate <class _Tp> 41047a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 41057a984708SDavid Chisnallvoid 41067a984708SDavid Chisnallsort(_Tp** __first, _Tp** __last) 41077a984708SDavid Chisnall{ 41087a984708SDavid Chisnall _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>()); 41097a984708SDavid Chisnall} 41107a984708SDavid Chisnall 41117a984708SDavid Chisnalltemplate <class _Tp> 41127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 41137a984708SDavid Chisnallvoid 41147a984708SDavid Chisnallsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last) 41157a984708SDavid Chisnall{ 41167a984708SDavid Chisnall _VSTD::sort(__first.base(), __last.base()); 41177a984708SDavid Chisnall} 41187a984708SDavid Chisnall 41197a984708SDavid Chisnalltemplate <class _Tp, class _Compare> 41207a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 41217a984708SDavid Chisnallvoid 41227a984708SDavid Chisnallsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp) 41237a984708SDavid Chisnall{ 41247a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 41257a984708SDavid Chisnall _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp); 41267a984708SDavid Chisnall} 41277a984708SDavid Chisnall 41284f7ab58eSDimitry Andric#ifdef _LIBCPP_MSVC 41297a984708SDavid Chisnall#pragma warning( push ) 41307a984708SDavid Chisnall#pragma warning( disable: 4231) 41314f7ab58eSDimitry Andric#endif // _LIBCPP_MSVC 41324f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&)) 41334f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 41344f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 41354f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 41364f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&)) 41374f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 41384f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&)) 41394f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 41404f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&)) 41414f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 41424f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 41434f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&)) 41444f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&)) 41454f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&)) 41464f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 41477a984708SDavid Chisnall 41484f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&)) 41494f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 41504f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 41514f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 41524f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&)) 41534f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 41544f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&)) 41554f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 41564f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&)) 41574f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 41584f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 41594f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&)) 41604f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&)) 41614f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&)) 41624f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 41637a984708SDavid Chisnall 41644f7ab58eSDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&)) 41654f7ab58eSDimitry Andric#ifdef _LIBCPP_MSVC 41667a984708SDavid Chisnall#pragma warning( pop ) 41674f7ab58eSDimitry Andric#endif // _LIBCPP_MSVC 41687a984708SDavid Chisnall 41697a984708SDavid Chisnall// lower_bound 41707a984708SDavid Chisnall 41717a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 41727a984708SDavid Chisnall_ForwardIterator 41737a984708SDavid Chisnall__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 41747a984708SDavid Chisnall{ 41757a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 41767a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 41777a984708SDavid Chisnall while (__len != 0) 41787a984708SDavid Chisnall { 41797a984708SDavid Chisnall difference_type __l2 = __len / 2; 41807a984708SDavid Chisnall _ForwardIterator __m = __first; 41817a984708SDavid Chisnall _VSTD::advance(__m, __l2); 41827a984708SDavid Chisnall if (__comp(*__m, __value_)) 41837a984708SDavid Chisnall { 41847a984708SDavid Chisnall __first = ++__m; 41857a984708SDavid Chisnall __len -= __l2 + 1; 41867a984708SDavid Chisnall } 41877a984708SDavid Chisnall else 41887a984708SDavid Chisnall __len = __l2; 41897a984708SDavid Chisnall } 41907a984708SDavid Chisnall return __first; 41917a984708SDavid Chisnall} 41927a984708SDavid Chisnall 41937a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 41947a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 41957a984708SDavid Chisnall_ForwardIterator 41967a984708SDavid Chisnalllower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 41977a984708SDavid Chisnall{ 41984f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 41997a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 42007a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 42017a984708SDavid Chisnall return __lower_bound<_Comp_ref>(__first, __last, __value_, __c); 42024f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 42037a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 42047a984708SDavid Chisnall return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp); 42054f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 42067a984708SDavid Chisnall} 42077a984708SDavid Chisnall 42087a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 42097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 42107a984708SDavid Chisnall_ForwardIterator 42117a984708SDavid Chisnalllower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 42127a984708SDavid Chisnall{ 42137a984708SDavid Chisnall return _VSTD::lower_bound(__first, __last, __value_, 42147a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 42157a984708SDavid Chisnall} 42167a984708SDavid Chisnall 42177a984708SDavid Chisnall// upper_bound 42187a984708SDavid Chisnall 42197a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 42207a984708SDavid Chisnall_ForwardIterator 42217a984708SDavid Chisnall__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 42227a984708SDavid Chisnall{ 42237a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 42247a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 42257a984708SDavid Chisnall while (__len != 0) 42267a984708SDavid Chisnall { 42277a984708SDavid Chisnall difference_type __l2 = __len / 2; 42287a984708SDavid Chisnall _ForwardIterator __m = __first; 42297a984708SDavid Chisnall _VSTD::advance(__m, __l2); 42307a984708SDavid Chisnall if (__comp(__value_, *__m)) 42317a984708SDavid Chisnall __len = __l2; 42327a984708SDavid Chisnall else 42337a984708SDavid Chisnall { 42347a984708SDavid Chisnall __first = ++__m; 42357a984708SDavid Chisnall __len -= __l2 + 1; 42367a984708SDavid Chisnall } 42377a984708SDavid Chisnall } 42387a984708SDavid Chisnall return __first; 42397a984708SDavid Chisnall} 42407a984708SDavid Chisnall 42417a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 42427a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 42437a984708SDavid Chisnall_ForwardIterator 42447a984708SDavid Chisnallupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 42457a984708SDavid Chisnall{ 42464f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 42477a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 42487a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 42497a984708SDavid Chisnall return __upper_bound<_Comp_ref>(__first, __last, __value_, __c); 42504f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 42517a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 42527a984708SDavid Chisnall return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp); 42534f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 42547a984708SDavid Chisnall} 42557a984708SDavid Chisnall 42567a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 42577a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 42587a984708SDavid Chisnall_ForwardIterator 42597a984708SDavid Chisnallupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 42607a984708SDavid Chisnall{ 42617a984708SDavid Chisnall return _VSTD::upper_bound(__first, __last, __value_, 42627a984708SDavid Chisnall __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>()); 42637a984708SDavid Chisnall} 42647a984708SDavid Chisnall 42657a984708SDavid Chisnall// equal_range 42667a984708SDavid Chisnall 42677a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 42687a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator> 42697a984708SDavid Chisnall__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 42707a984708SDavid Chisnall{ 42717a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 42727a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 42737a984708SDavid Chisnall while (__len != 0) 42747a984708SDavid Chisnall { 42757a984708SDavid Chisnall difference_type __l2 = __len / 2; 42767a984708SDavid Chisnall _ForwardIterator __m = __first; 42777a984708SDavid Chisnall _VSTD::advance(__m, __l2); 42787a984708SDavid Chisnall if (__comp(*__m, __value_)) 42797a984708SDavid Chisnall { 42807a984708SDavid Chisnall __first = ++__m; 42817a984708SDavid Chisnall __len -= __l2 + 1; 42827a984708SDavid Chisnall } 42837a984708SDavid Chisnall else if (__comp(__value_, *__m)) 42847a984708SDavid Chisnall { 42857a984708SDavid Chisnall __last = __m; 42867a984708SDavid Chisnall __len = __l2; 42877a984708SDavid Chisnall } 42887a984708SDavid Chisnall else 42897a984708SDavid Chisnall { 42907a984708SDavid Chisnall _ForwardIterator __mp1 = __m; 42917a984708SDavid Chisnall return pair<_ForwardIterator, _ForwardIterator> 42927a984708SDavid Chisnall ( 42937a984708SDavid Chisnall __lower_bound<_Compare>(__first, __m, __value_, __comp), 42947a984708SDavid Chisnall __upper_bound<_Compare>(++__mp1, __last, __value_, __comp) 42957a984708SDavid Chisnall ); 42967a984708SDavid Chisnall } 42977a984708SDavid Chisnall } 42987a984708SDavid Chisnall return pair<_ForwardIterator, _ForwardIterator>(__first, __first); 42997a984708SDavid Chisnall} 43007a984708SDavid Chisnall 43017a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 43027a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 43037a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator> 43047a984708SDavid Chisnallequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 43057a984708SDavid Chisnall{ 43064f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 43077a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 43087a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 43097a984708SDavid Chisnall return __equal_range<_Comp_ref>(__first, __last, __value_, __c); 43104f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 43117a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 43127a984708SDavid Chisnall return __equal_range<_Comp_ref>(__first, __last, __value_, __comp); 43134f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 43147a984708SDavid Chisnall} 43157a984708SDavid Chisnall 43167a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 43177a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 43187a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator> 43197a984708SDavid Chisnallequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 43207a984708SDavid Chisnall{ 43217a984708SDavid Chisnall return _VSTD::equal_range(__first, __last, __value_, 43227a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 43237a984708SDavid Chisnall} 43247a984708SDavid Chisnall 43257a984708SDavid Chisnall// binary_search 43267a984708SDavid Chisnall 43277a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 43287a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 43297a984708SDavid Chisnallbool 43307a984708SDavid Chisnall__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 43317a984708SDavid Chisnall{ 43327a984708SDavid Chisnall __first = __lower_bound<_Compare>(__first, __last, __value_, __comp); 43337a984708SDavid Chisnall return __first != __last && !__comp(__value_, *__first); 43347a984708SDavid Chisnall} 43357a984708SDavid Chisnall 43367a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 43377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 43387a984708SDavid Chisnallbool 43397a984708SDavid Chisnallbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 43407a984708SDavid Chisnall{ 43414f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 43427a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 43437a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 43447a984708SDavid Chisnall return __binary_search<_Comp_ref>(__first, __last, __value_, __c); 43454f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 43467a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 43477a984708SDavid Chisnall return __binary_search<_Comp_ref>(__first, __last, __value_, __comp); 43484f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 43497a984708SDavid Chisnall} 43507a984708SDavid Chisnall 43517a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 43527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 43537a984708SDavid Chisnallbool 43547a984708SDavid Chisnallbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 43557a984708SDavid Chisnall{ 43567a984708SDavid Chisnall return _VSTD::binary_search(__first, __last, __value_, 43577a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 43587a984708SDavid Chisnall} 43597a984708SDavid Chisnall 43607a984708SDavid Chisnall// merge 43617a984708SDavid Chisnall 43627a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 43637a984708SDavid Chisnall_OutputIterator 43647a984708SDavid Chisnall__merge(_InputIterator1 __first1, _InputIterator1 __last1, 43657a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 43667a984708SDavid Chisnall{ 43677a984708SDavid Chisnall for (; __first1 != __last1; ++__result) 43687a984708SDavid Chisnall { 43697a984708SDavid Chisnall if (__first2 == __last2) 43707a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 43717a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 43727a984708SDavid Chisnall { 43737a984708SDavid Chisnall *__result = *__first2; 43747a984708SDavid Chisnall ++__first2; 43757a984708SDavid Chisnall } 43767a984708SDavid Chisnall else 43777a984708SDavid Chisnall { 43787a984708SDavid Chisnall *__result = *__first1; 43797a984708SDavid Chisnall ++__first1; 43807a984708SDavid Chisnall } 43817a984708SDavid Chisnall } 43827a984708SDavid Chisnall return _VSTD::copy(__first2, __last2, __result); 43837a984708SDavid Chisnall} 43847a984708SDavid Chisnall 43857a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 43867a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 43877a984708SDavid Chisnall_OutputIterator 43887a984708SDavid Chisnallmerge(_InputIterator1 __first1, _InputIterator1 __last1, 43897a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 43907a984708SDavid Chisnall{ 43914f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 43927a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 43937a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 43947a984708SDavid Chisnall return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 43954f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 43967a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 43977a984708SDavid Chisnall return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 43984f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 43997a984708SDavid Chisnall} 44007a984708SDavid Chisnall 44017a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 44027a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 44037a984708SDavid Chisnall_OutputIterator 44047a984708SDavid Chisnallmerge(_InputIterator1 __first1, _InputIterator1 __last1, 44057a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 44067a984708SDavid Chisnall{ 44077a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 44087a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 44097a984708SDavid Chisnall return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>()); 44107a984708SDavid Chisnall} 44117a984708SDavid Chisnall 44127a984708SDavid Chisnall// inplace_merge 44137a984708SDavid Chisnall 4414854fa44bSDimitry Andrictemplate <class _Compare, class _InputIterator1, class _InputIterator2, 4415854fa44bSDimitry Andric class _OutputIterator> 4416854fa44bSDimitry Andricvoid __half_inplace_merge(_InputIterator1 __first1, _InputIterator1 __last1, 4417854fa44bSDimitry Andric _InputIterator2 __first2, _InputIterator2 __last2, 4418854fa44bSDimitry Andric _OutputIterator __result, _Compare __comp) 4419854fa44bSDimitry Andric{ 4420854fa44bSDimitry Andric for (; __first1 != __last1; ++__result) 4421854fa44bSDimitry Andric { 4422854fa44bSDimitry Andric if (__first2 == __last2) 4423854fa44bSDimitry Andric { 4424854fa44bSDimitry Andric _VSTD::move(__first1, __last1, __result); 4425854fa44bSDimitry Andric return; 4426854fa44bSDimitry Andric } 4427854fa44bSDimitry Andric 4428854fa44bSDimitry Andric if (__comp(*__first2, *__first1)) 4429854fa44bSDimitry Andric { 4430854fa44bSDimitry Andric *__result = _VSTD::move(*__first2); 4431854fa44bSDimitry Andric ++__first2; 4432854fa44bSDimitry Andric } 4433854fa44bSDimitry Andric else 4434854fa44bSDimitry Andric { 4435854fa44bSDimitry Andric *__result = _VSTD::move(*__first1); 4436854fa44bSDimitry Andric ++__first1; 4437854fa44bSDimitry Andric } 4438854fa44bSDimitry Andric } 4439854fa44bSDimitry Andric // __first2 through __last2 are already in the right spot. 4440854fa44bSDimitry Andric} 4441854fa44bSDimitry Andric 44427a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 44437a984708SDavid Chisnallvoid 44447a984708SDavid Chisnall__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 44457a984708SDavid Chisnall _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 44467a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 44477a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::value_type* __buff) 44487a984708SDavid Chisnall{ 44497a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 44507a984708SDavid Chisnall __destruct_n __d(0); 44517a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 44527a984708SDavid Chisnall if (__len1 <= __len2) 44537a984708SDavid Chisnall { 44547a984708SDavid Chisnall value_type* __p = __buff; 4455d72607e9SDimitry Andric for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, ++__p) 44567a984708SDavid Chisnall ::new(__p) value_type(_VSTD::move(*__i)); 4457854fa44bSDimitry Andric __half_inplace_merge(__buff, __p, __middle, __last, __first, __comp); 44587a984708SDavid Chisnall } 44597a984708SDavid Chisnall else 44607a984708SDavid Chisnall { 44617a984708SDavid Chisnall value_type* __p = __buff; 4462d72607e9SDimitry Andric for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, ++__p) 44637a984708SDavid Chisnall ::new(__p) value_type(_VSTD::move(*__i)); 44647a984708SDavid Chisnall typedef reverse_iterator<_BidirectionalIterator> _RBi; 44657a984708SDavid Chisnall typedef reverse_iterator<value_type*> _Rv; 4466854fa44bSDimitry Andric __half_inplace_merge(_Rv(__p), _Rv(__buff), 4467854fa44bSDimitry Andric _RBi(__middle), _RBi(__first), 44687a984708SDavid Chisnall _RBi(__last), __negate<_Compare>(__comp)); 44697a984708SDavid Chisnall } 44707a984708SDavid Chisnall} 44717a984708SDavid Chisnall 44727a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 44737a984708SDavid Chisnallvoid 44747a984708SDavid Chisnall__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 44757a984708SDavid Chisnall _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 44767a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 44777a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size) 44787a984708SDavid Chisnall{ 44797a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 44807a984708SDavid Chisnall while (true) 44817a984708SDavid Chisnall { 44827a984708SDavid Chisnall // if __middle == __last, we're done 44837a984708SDavid Chisnall if (__len2 == 0) 44847a984708SDavid Chisnall return; 4485854fa44bSDimitry Andric if (__len1 <= __buff_size || __len2 <= __buff_size) 4486854fa44bSDimitry Andric return __buffered_inplace_merge<_Compare> 4487854fa44bSDimitry Andric (__first, __middle, __last, __comp, __len1, __len2, __buff); 44887a984708SDavid Chisnall // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0 4489d72607e9SDimitry Andric for (; true; ++__first, (void) --__len1) 44907a984708SDavid Chisnall { 44917a984708SDavid Chisnall if (__len1 == 0) 44927a984708SDavid Chisnall return; 44937a984708SDavid Chisnall if (__comp(*__middle, *__first)) 44947a984708SDavid Chisnall break; 44957a984708SDavid Chisnall } 44967a984708SDavid Chisnall // __first < __middle < __last 44977a984708SDavid Chisnall // *__first > *__middle 44987a984708SDavid Chisnall // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that 44997a984708SDavid Chisnall // all elements in: 45007a984708SDavid Chisnall // [__first, __m1) <= [__middle, __m2) 45017a984708SDavid Chisnall // [__middle, __m2) < [__m1, __middle) 45027a984708SDavid Chisnall // [__m1, __middle) <= [__m2, __last) 45037a984708SDavid Chisnall // and __m1 or __m2 is in the middle of its range 45047a984708SDavid Chisnall _BidirectionalIterator __m1; // "median" of [__first, __middle) 45057a984708SDavid Chisnall _BidirectionalIterator __m2; // "median" of [__middle, __last) 45067a984708SDavid Chisnall difference_type __len11; // distance(__first, __m1) 45077a984708SDavid Chisnall difference_type __len21; // distance(__middle, __m2) 45087a984708SDavid Chisnall // binary search smaller range 45097a984708SDavid Chisnall if (__len1 < __len2) 45107a984708SDavid Chisnall { // __len >= 1, __len2 >= 2 45117a984708SDavid Chisnall __len21 = __len2 / 2; 45127a984708SDavid Chisnall __m2 = __middle; 45137a984708SDavid Chisnall _VSTD::advance(__m2, __len21); 45147a984708SDavid Chisnall __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp); 45157a984708SDavid Chisnall __len11 = _VSTD::distance(__first, __m1); 45167a984708SDavid Chisnall } 45177a984708SDavid Chisnall else 45187a984708SDavid Chisnall { 45197a984708SDavid Chisnall if (__len1 == 1) 45207a984708SDavid Chisnall { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1 45217a984708SDavid Chisnall // It is known *__first > *__middle 45227a984708SDavid Chisnall swap(*__first, *__middle); 45237a984708SDavid Chisnall return; 45247a984708SDavid Chisnall } 45257a984708SDavid Chisnall // __len1 >= 2, __len2 >= 1 45267a984708SDavid Chisnall __len11 = __len1 / 2; 45277a984708SDavid Chisnall __m1 = __first; 45287a984708SDavid Chisnall _VSTD::advance(__m1, __len11); 45297a984708SDavid Chisnall __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp); 45307a984708SDavid Chisnall __len21 = _VSTD::distance(__middle, __m2); 45317a984708SDavid Chisnall } 45327a984708SDavid Chisnall difference_type __len12 = __len1 - __len11; // distance(__m1, __middle) 45337a984708SDavid Chisnall difference_type __len22 = __len2 - __len21; // distance(__m2, __last) 45347a984708SDavid Chisnall // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) 45357a984708SDavid Chisnall // swap middle two partitions 45367a984708SDavid Chisnall __middle = _VSTD::rotate(__m1, __middle, __m2); 45377a984708SDavid Chisnall // __len12 and __len21 now have swapped meanings 45387a984708SDavid Chisnall // merge smaller range with recurisve call and larger with tail recursion elimination 45397a984708SDavid Chisnall if (__len11 + __len21 < __len12 + __len22) 45407a984708SDavid Chisnall { 45417a984708SDavid Chisnall __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 45427a984708SDavid Chisnall// __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 45437a984708SDavid Chisnall __first = __middle; 45447a984708SDavid Chisnall __middle = __m2; 45457a984708SDavid Chisnall __len1 = __len12; 45467a984708SDavid Chisnall __len2 = __len22; 45477a984708SDavid Chisnall } 45487a984708SDavid Chisnall else 45497a984708SDavid Chisnall { 45507a984708SDavid Chisnall __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 45517a984708SDavid Chisnall// __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 45527a984708SDavid Chisnall __last = __middle; 45537a984708SDavid Chisnall __middle = __m1; 45547a984708SDavid Chisnall __len1 = __len11; 45557a984708SDavid Chisnall __len2 = __len21; 45567a984708SDavid Chisnall } 45577a984708SDavid Chisnall } 45587a984708SDavid Chisnall} 45597a984708SDavid Chisnall 45607a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare> 45617a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 45627a984708SDavid Chisnallvoid 45637a984708SDavid Chisnallinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 45647a984708SDavid Chisnall _Compare __comp) 45657a984708SDavid Chisnall{ 45667a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 45677a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 45687a984708SDavid Chisnall difference_type __len1 = _VSTD::distance(__first, __middle); 45697a984708SDavid Chisnall difference_type __len2 = _VSTD::distance(__middle, __last); 45707a984708SDavid Chisnall difference_type __buf_size = _VSTD::min(__len1, __len2); 4571854fa44bSDimitry Andric pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size); 4572854fa44bSDimitry Andric unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first); 4573854fa44bSDimitry Andric 45744f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 45757a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 45767a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 45777a984708SDavid Chisnall return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2, 45787a984708SDavid Chisnall __buf.first, __buf.second); 45794f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 45807a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 45817a984708SDavid Chisnall return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2, 45827a984708SDavid Chisnall __buf.first, __buf.second); 45834f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 45847a984708SDavid Chisnall} 45857a984708SDavid Chisnall 45867a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 45877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 45887a984708SDavid Chisnallvoid 45897a984708SDavid Chisnallinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) 45907a984708SDavid Chisnall{ 45917a984708SDavid Chisnall _VSTD::inplace_merge(__first, __middle, __last, 45927a984708SDavid Chisnall __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 45937a984708SDavid Chisnall} 45947a984708SDavid Chisnall 45957a984708SDavid Chisnall// stable_sort 45967a984708SDavid Chisnall 45977a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2> 45987a984708SDavid Chisnallvoid 45997a984708SDavid Chisnall__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1, 46007a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, 46017a984708SDavid Chisnall typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp) 46027a984708SDavid Chisnall{ 46037a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type value_type; 46047a984708SDavid Chisnall __destruct_n __d(0); 46057a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__result, __d); 46067a984708SDavid Chisnall for (; true; ++__result) 46077a984708SDavid Chisnall { 46087a984708SDavid Chisnall if (__first1 == __last1) 46097a984708SDavid Chisnall { 46107a984708SDavid Chisnall for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0)) 46117a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first2)); 46127a984708SDavid Chisnall __h.release(); 46137a984708SDavid Chisnall return; 46147a984708SDavid Chisnall } 46157a984708SDavid Chisnall if (__first2 == __last2) 46167a984708SDavid Chisnall { 46177a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0)) 46187a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first1)); 46197a984708SDavid Chisnall __h.release(); 46207a984708SDavid Chisnall return; 46217a984708SDavid Chisnall } 46227a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 46237a984708SDavid Chisnall { 46247a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first2)); 46257a984708SDavid Chisnall __d.__incr((value_type*)0); 46267a984708SDavid Chisnall ++__first2; 46277a984708SDavid Chisnall } 46287a984708SDavid Chisnall else 46297a984708SDavid Chisnall { 46307a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first1)); 46317a984708SDavid Chisnall __d.__incr((value_type*)0); 46327a984708SDavid Chisnall ++__first1; 46337a984708SDavid Chisnall } 46347a984708SDavid Chisnall } 46357a984708SDavid Chisnall} 46367a984708SDavid Chisnall 46377a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 46387a984708SDavid Chisnallvoid 46397a984708SDavid Chisnall__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1, 46407a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, 46417a984708SDavid Chisnall _OutputIterator __result, _Compare __comp) 46427a984708SDavid Chisnall{ 46437a984708SDavid Chisnall for (; __first1 != __last1; ++__result) 46447a984708SDavid Chisnall { 46457a984708SDavid Chisnall if (__first2 == __last2) 46467a984708SDavid Chisnall { 46477a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__result) 46487a984708SDavid Chisnall *__result = _VSTD::move(*__first1); 46497a984708SDavid Chisnall return; 46507a984708SDavid Chisnall } 46517a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 46527a984708SDavid Chisnall { 46537a984708SDavid Chisnall *__result = _VSTD::move(*__first2); 46547a984708SDavid Chisnall ++__first2; 46557a984708SDavid Chisnall } 46567a984708SDavid Chisnall else 46577a984708SDavid Chisnall { 46587a984708SDavid Chisnall *__result = _VSTD::move(*__first1); 46597a984708SDavid Chisnall ++__first1; 46607a984708SDavid Chisnall } 46617a984708SDavid Chisnall } 46627a984708SDavid Chisnall for (; __first2 != __last2; ++__first2, ++__result) 46637a984708SDavid Chisnall *__result = _VSTD::move(*__first2); 46647a984708SDavid Chisnall} 46657a984708SDavid Chisnall 46667a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 46677a984708SDavid Chisnallvoid 46687a984708SDavid Chisnall__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 46697a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len, 46707a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size); 46717a984708SDavid Chisnall 46727a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 46737a984708SDavid Chisnallvoid 46747a984708SDavid Chisnall__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp, 46757a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len, 46767a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::value_type* __first2) 46777a984708SDavid Chisnall{ 46787a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 46797a984708SDavid Chisnall switch (__len) 46807a984708SDavid Chisnall { 46817a984708SDavid Chisnall case 0: 46827a984708SDavid Chisnall return; 46837a984708SDavid Chisnall case 1: 46847a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__first1)); 46857a984708SDavid Chisnall return; 46867a984708SDavid Chisnall case 2: 46877a984708SDavid Chisnall __destruct_n __d(0); 46887a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h2(__first2, __d); 46897a984708SDavid Chisnall if (__comp(*--__last1, *__first1)) 46907a984708SDavid Chisnall { 46917a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__last1)); 46927a984708SDavid Chisnall __d.__incr((value_type*)0); 46937a984708SDavid Chisnall ++__first2; 46947a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__first1)); 46957a984708SDavid Chisnall } 46967a984708SDavid Chisnall else 46977a984708SDavid Chisnall { 46987a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__first1)); 46997a984708SDavid Chisnall __d.__incr((value_type*)0); 47007a984708SDavid Chisnall ++__first2; 47017a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__last1)); 47027a984708SDavid Chisnall } 47037a984708SDavid Chisnall __h2.release(); 47047a984708SDavid Chisnall return; 47057a984708SDavid Chisnall } 47067a984708SDavid Chisnall if (__len <= 8) 47077a984708SDavid Chisnall { 47087a984708SDavid Chisnall __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp); 47097a984708SDavid Chisnall return; 47107a984708SDavid Chisnall } 47117a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 47127a984708SDavid Chisnall _RandomAccessIterator __m = __first1 + __l2; 47137a984708SDavid Chisnall __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2); 47147a984708SDavid Chisnall __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2); 47157a984708SDavid Chisnall __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp); 47167a984708SDavid Chisnall} 47177a984708SDavid Chisnall 47187a984708SDavid Chisnalltemplate <class _Tp> 47197a984708SDavid Chisnallstruct __stable_sort_switch 47207a984708SDavid Chisnall{ 47217a984708SDavid Chisnall static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value; 47227a984708SDavid Chisnall}; 47237a984708SDavid Chisnall 47247a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 47257a984708SDavid Chisnallvoid 47267a984708SDavid Chisnall__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 47277a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len, 47287a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size) 47297a984708SDavid Chisnall{ 47307a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 47317a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 47327a984708SDavid Chisnall switch (__len) 47337a984708SDavid Chisnall { 47347a984708SDavid Chisnall case 0: 47357a984708SDavid Chisnall case 1: 47367a984708SDavid Chisnall return; 47377a984708SDavid Chisnall case 2: 47387a984708SDavid Chisnall if (__comp(*--__last, *__first)) 47397a984708SDavid Chisnall swap(*__first, *__last); 47407a984708SDavid Chisnall return; 47417a984708SDavid Chisnall } 47427a984708SDavid Chisnall if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 47437a984708SDavid Chisnall { 47447a984708SDavid Chisnall __insertion_sort<_Compare>(__first, __last, __comp); 47457a984708SDavid Chisnall return; 47467a984708SDavid Chisnall } 47477a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 47487a984708SDavid Chisnall _RandomAccessIterator __m = __first + __l2; 47497a984708SDavid Chisnall if (__len <= __buff_size) 47507a984708SDavid Chisnall { 47517a984708SDavid Chisnall __destruct_n __d(0); 47527a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 47537a984708SDavid Chisnall __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff); 47547a984708SDavid Chisnall __d.__set(__l2, (value_type*)0); 47557a984708SDavid Chisnall __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2); 47567a984708SDavid Chisnall __d.__set(__len, (value_type*)0); 47577a984708SDavid Chisnall __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp); 47587a984708SDavid Chisnall// __merge<_Compare>(move_iterator<value_type*>(__buff), 47597a984708SDavid Chisnall// move_iterator<value_type*>(__buff + __l2), 47607a984708SDavid Chisnall// move_iterator<_RandomAccessIterator>(__buff + __l2), 47617a984708SDavid Chisnall// move_iterator<_RandomAccessIterator>(__buff + __len), 47627a984708SDavid Chisnall// __first, __comp); 47637a984708SDavid Chisnall return; 47647a984708SDavid Chisnall } 47657a984708SDavid Chisnall __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size); 47667a984708SDavid Chisnall __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size); 47677a984708SDavid Chisnall __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size); 47687a984708SDavid Chisnall} 47697a984708SDavid Chisnall 47707a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 47717a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47727a984708SDavid Chisnallvoid 47737a984708SDavid Chisnallstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 47747a984708SDavid Chisnall{ 47757a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 47767a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 47777a984708SDavid Chisnall difference_type __len = __last - __first; 47787a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __buf(0, 0); 47797a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 47807a984708SDavid Chisnall if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 47817a984708SDavid Chisnall { 47827a984708SDavid Chisnall __buf = _VSTD::get_temporary_buffer<value_type>(__len); 47837a984708SDavid Chisnall __h.reset(__buf.first); 47847a984708SDavid Chisnall } 47854f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 47867a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 47877a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 47887a984708SDavid Chisnall __stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second); 47894f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 47907a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 47917a984708SDavid Chisnall __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second); 47924f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 47937a984708SDavid Chisnall} 47947a984708SDavid Chisnall 47957a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 47967a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47977a984708SDavid Chisnallvoid 47987a984708SDavid Chisnallstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) 47997a984708SDavid Chisnall{ 48007a984708SDavid Chisnall _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 48017a984708SDavid Chisnall} 48027a984708SDavid Chisnall 48037a984708SDavid Chisnall// is_heap_until 48047a984708SDavid Chisnall 48057a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 48067a984708SDavid Chisnall_RandomAccessIterator 48077a984708SDavid Chisnallis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 48087a984708SDavid Chisnall{ 48097a984708SDavid Chisnall typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type; 48107a984708SDavid Chisnall difference_type __len = __last - __first; 48117a984708SDavid Chisnall difference_type __p = 0; 48127a984708SDavid Chisnall difference_type __c = 1; 48137a984708SDavid Chisnall _RandomAccessIterator __pp = __first; 48147a984708SDavid Chisnall while (__c < __len) 48157a984708SDavid Chisnall { 48167a984708SDavid Chisnall _RandomAccessIterator __cp = __first + __c; 48177a984708SDavid Chisnall if (__comp(*__pp, *__cp)) 48187a984708SDavid Chisnall return __cp; 48197a984708SDavid Chisnall ++__c; 48207a984708SDavid Chisnall ++__cp; 48217a984708SDavid Chisnall if (__c == __len) 48227a984708SDavid Chisnall return __last; 48237a984708SDavid Chisnall if (__comp(*__pp, *__cp)) 48247a984708SDavid Chisnall return __cp; 48257a984708SDavid Chisnall ++__p; 48267a984708SDavid Chisnall ++__pp; 48277a984708SDavid Chisnall __c = 2 * __p + 1; 48287a984708SDavid Chisnall } 48297a984708SDavid Chisnall return __last; 48307a984708SDavid Chisnall} 48317a984708SDavid Chisnall 48327a984708SDavid Chisnalltemplate<class _RandomAccessIterator> 48337a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 48347a984708SDavid Chisnall_RandomAccessIterator 48357a984708SDavid Chisnallis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) 48367a984708SDavid Chisnall{ 48377a984708SDavid Chisnall return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 48387a984708SDavid Chisnall} 48397a984708SDavid Chisnall 48407a984708SDavid Chisnall// is_heap 48417a984708SDavid Chisnall 48427a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 48437a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 48447a984708SDavid Chisnallbool 48457a984708SDavid Chisnallis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 48467a984708SDavid Chisnall{ 48477a984708SDavid Chisnall return _VSTD::is_heap_until(__first, __last, __comp) == __last; 48487a984708SDavid Chisnall} 48497a984708SDavid Chisnall 48507a984708SDavid Chisnalltemplate<class _RandomAccessIterator> 48517a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 48527a984708SDavid Chisnallbool 48537a984708SDavid Chisnallis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 48547a984708SDavid Chisnall{ 48557a984708SDavid Chisnall return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 48567a984708SDavid Chisnall} 48577a984708SDavid Chisnall 48587a984708SDavid Chisnall// push_heap 48597a984708SDavid Chisnall 48607a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 48617a984708SDavid Chisnallvoid 4862d72607e9SDimitry Andric__sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 48637a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len) 48647a984708SDavid Chisnall{ 48657a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 48667a984708SDavid Chisnall if (__len > 1) 48677a984708SDavid Chisnall { 48687a984708SDavid Chisnall __len = (__len - 2) / 2; 48697a984708SDavid Chisnall _RandomAccessIterator __ptr = __first + __len; 48707a984708SDavid Chisnall if (__comp(*__ptr, *--__last)) 48717a984708SDavid Chisnall { 48727a984708SDavid Chisnall value_type __t(_VSTD::move(*__last)); 48737a984708SDavid Chisnall do 48747a984708SDavid Chisnall { 48757a984708SDavid Chisnall *__last = _VSTD::move(*__ptr); 48767a984708SDavid Chisnall __last = __ptr; 48777a984708SDavid Chisnall if (__len == 0) 48787a984708SDavid Chisnall break; 48797a984708SDavid Chisnall __len = (__len - 1) / 2; 48807a984708SDavid Chisnall __ptr = __first + __len; 48817a984708SDavid Chisnall } while (__comp(*__ptr, __t)); 48827a984708SDavid Chisnall *__last = _VSTD::move(__t); 48837a984708SDavid Chisnall } 48847a984708SDavid Chisnall } 48857a984708SDavid Chisnall} 48867a984708SDavid Chisnall 48877a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 48887a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 48897a984708SDavid Chisnallvoid 48907a984708SDavid Chisnallpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 48917a984708SDavid Chisnall{ 48924f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 48937a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 48947a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 4895d72607e9SDimitry Andric __sift_up<_Comp_ref>(__first, __last, __c, __last - __first); 48964f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 48977a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4898d72607e9SDimitry Andric __sift_up<_Comp_ref>(__first, __last, __comp, __last - __first); 48994f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 49007a984708SDavid Chisnall} 49017a984708SDavid Chisnall 49027a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 49037a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 49047a984708SDavid Chisnallvoid 49057a984708SDavid Chisnallpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 49067a984708SDavid Chisnall{ 49077a984708SDavid Chisnall _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 49087a984708SDavid Chisnall} 49097a984708SDavid Chisnall 49107a984708SDavid Chisnall// pop_heap 49117a984708SDavid Chisnall 49127a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 4913d72607e9SDimitry Andricvoid 4914aed8d94eSDimitry Andric__sift_down(_RandomAccessIterator __first, _RandomAccessIterator /*__last*/, 4915aed8d94eSDimitry Andric _Compare __comp, 4916d72607e9SDimitry Andric typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4917d72607e9SDimitry Andric _RandomAccessIterator __start) 4918d72607e9SDimitry Andric{ 4919d72607e9SDimitry Andric typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4920d72607e9SDimitry Andric typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4921d72607e9SDimitry Andric // left-child of __start is at 2 * __start + 1 4922d72607e9SDimitry Andric // right-child of __start is at 2 * __start + 2 4923d72607e9SDimitry Andric difference_type __child = __start - __first; 4924d72607e9SDimitry Andric 4925d72607e9SDimitry Andric if (__len < 2 || (__len - 2) / 2 < __child) 4926d72607e9SDimitry Andric return; 4927d72607e9SDimitry Andric 4928d72607e9SDimitry Andric __child = 2 * __child + 1; 4929d72607e9SDimitry Andric _RandomAccessIterator __child_i = __first + __child; 4930d72607e9SDimitry Andric 4931d72607e9SDimitry Andric if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + 1))) { 4932d72607e9SDimitry Andric // right-child exists and is greater than left-child 4933d72607e9SDimitry Andric ++__child_i; 4934d72607e9SDimitry Andric ++__child; 4935d72607e9SDimitry Andric } 4936d72607e9SDimitry Andric 4937d72607e9SDimitry Andric // check if we are in heap-order 4938d72607e9SDimitry Andric if (__comp(*__child_i, *__start)) 4939d72607e9SDimitry Andric // we are, __start is larger than it's largest child 4940d72607e9SDimitry Andric return; 4941d72607e9SDimitry Andric 4942d72607e9SDimitry Andric value_type __top(_VSTD::move(*__start)); 4943d72607e9SDimitry Andric do 4944d72607e9SDimitry Andric { 4945d72607e9SDimitry Andric // we are not in heap-order, swap the parent with it's largest child 4946d72607e9SDimitry Andric *__start = _VSTD::move(*__child_i); 4947d72607e9SDimitry Andric __start = __child_i; 4948d72607e9SDimitry Andric 4949d72607e9SDimitry Andric if ((__len - 2) / 2 < __child) 4950d72607e9SDimitry Andric break; 4951d72607e9SDimitry Andric 4952d72607e9SDimitry Andric // recompute the child based off of the updated parent 4953d72607e9SDimitry Andric __child = 2 * __child + 1; 4954d72607e9SDimitry Andric __child_i = __first + __child; 4955d72607e9SDimitry Andric 4956d72607e9SDimitry Andric if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + 1))) { 4957d72607e9SDimitry Andric // right-child exists and is greater than left-child 4958d72607e9SDimitry Andric ++__child_i; 4959d72607e9SDimitry Andric ++__child; 4960d72607e9SDimitry Andric } 4961d72607e9SDimitry Andric 4962d72607e9SDimitry Andric // check if we are in heap-order 4963d72607e9SDimitry Andric } while (!__comp(*__child_i, __top)); 4964d72607e9SDimitry Andric *__start = _VSTD::move(__top); 4965d72607e9SDimitry Andric} 4966d72607e9SDimitry Andric 4967d72607e9SDimitry Andrictemplate <class _Compare, class _RandomAccessIterator> 49687a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 49697a984708SDavid Chisnallvoid 49707a984708SDavid Chisnall__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 49717a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len) 49727a984708SDavid Chisnall{ 49737a984708SDavid Chisnall if (__len > 1) 49747a984708SDavid Chisnall { 49757a984708SDavid Chisnall swap(*__first, *--__last); 4976d72607e9SDimitry Andric __sift_down<_Compare>(__first, __last, __comp, __len - 1, __first); 49777a984708SDavid Chisnall } 49787a984708SDavid Chisnall} 49797a984708SDavid Chisnall 49807a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 49817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 49827a984708SDavid Chisnallvoid 49837a984708SDavid Chisnallpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 49847a984708SDavid Chisnall{ 49854f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 49867a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 49877a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 49887a984708SDavid Chisnall __pop_heap<_Comp_ref>(__first, __last, __c, __last - __first); 49894f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 49907a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 49917a984708SDavid Chisnall __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first); 49924f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 49937a984708SDavid Chisnall} 49947a984708SDavid Chisnall 49957a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 49967a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 49977a984708SDavid Chisnallvoid 49987a984708SDavid Chisnallpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 49997a984708SDavid Chisnall{ 50007a984708SDavid Chisnall _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 50017a984708SDavid Chisnall} 50027a984708SDavid Chisnall 50037a984708SDavid Chisnall// make_heap 50047a984708SDavid Chisnall 50057a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 50067a984708SDavid Chisnallvoid 50077a984708SDavid Chisnall__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 50087a984708SDavid Chisnall{ 50097a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 50107a984708SDavid Chisnall difference_type __n = __last - __first; 50117a984708SDavid Chisnall if (__n > 1) 50127a984708SDavid Chisnall { 5013d72607e9SDimitry Andric // start from the first parent, there is no need to consider children 5014d72607e9SDimitry Andric for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start) 5015d72607e9SDimitry Andric { 5016d72607e9SDimitry Andric __sift_down<_Compare>(__first, __last, __comp, __n, __first + __start); 5017d72607e9SDimitry Andric } 50187a984708SDavid Chisnall } 50197a984708SDavid Chisnall} 50207a984708SDavid Chisnall 50217a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 50227a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50237a984708SDavid Chisnallvoid 50247a984708SDavid Chisnallmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 50257a984708SDavid Chisnall{ 50264f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 50277a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 50287a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 50297a984708SDavid Chisnall __make_heap<_Comp_ref>(__first, __last, __c); 50304f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 50317a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 50327a984708SDavid Chisnall __make_heap<_Comp_ref>(__first, __last, __comp); 50334f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 50347a984708SDavid Chisnall} 50357a984708SDavid Chisnall 50367a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 50377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50387a984708SDavid Chisnallvoid 50397a984708SDavid Chisnallmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 50407a984708SDavid Chisnall{ 50417a984708SDavid Chisnall _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 50427a984708SDavid Chisnall} 50437a984708SDavid Chisnall 50447a984708SDavid Chisnall// sort_heap 50457a984708SDavid Chisnall 50467a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 50477a984708SDavid Chisnallvoid 50487a984708SDavid Chisnall__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 50497a984708SDavid Chisnall{ 50507a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 50517a984708SDavid Chisnall for (difference_type __n = __last - __first; __n > 1; --__last, --__n) 50527a984708SDavid Chisnall __pop_heap<_Compare>(__first, __last, __comp, __n); 50537a984708SDavid Chisnall} 50547a984708SDavid Chisnall 50557a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 50567a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50577a984708SDavid Chisnallvoid 50587a984708SDavid Chisnallsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 50597a984708SDavid Chisnall{ 50604f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 50617a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 50627a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 50637a984708SDavid Chisnall __sort_heap<_Comp_ref>(__first, __last, __c); 50644f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 50657a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 50667a984708SDavid Chisnall __sort_heap<_Comp_ref>(__first, __last, __comp); 50674f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 50687a984708SDavid Chisnall} 50697a984708SDavid Chisnall 50707a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 50717a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50727a984708SDavid Chisnallvoid 50737a984708SDavid Chisnallsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 50747a984708SDavid Chisnall{ 50757a984708SDavid Chisnall _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 50767a984708SDavid Chisnall} 50777a984708SDavid Chisnall 50787a984708SDavid Chisnall// partial_sort 50797a984708SDavid Chisnall 50807a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 50817a984708SDavid Chisnallvoid 50827a984708SDavid Chisnall__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 50837a984708SDavid Chisnall _Compare __comp) 50847a984708SDavid Chisnall{ 50857a984708SDavid Chisnall __make_heap<_Compare>(__first, __middle, __comp); 50867a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first; 50877a984708SDavid Chisnall for (_RandomAccessIterator __i = __middle; __i != __last; ++__i) 50887a984708SDavid Chisnall { 50897a984708SDavid Chisnall if (__comp(*__i, *__first)) 50907a984708SDavid Chisnall { 50917a984708SDavid Chisnall swap(*__i, *__first); 5092d72607e9SDimitry Andric __sift_down<_Compare>(__first, __middle, __comp, __len, __first); 50937a984708SDavid Chisnall } 50947a984708SDavid Chisnall } 50957a984708SDavid Chisnall __sort_heap<_Compare>(__first, __middle, __comp); 50967a984708SDavid Chisnall} 50977a984708SDavid Chisnall 50987a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 50997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51007a984708SDavid Chisnallvoid 51017a984708SDavid Chisnallpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 51027a984708SDavid Chisnall _Compare __comp) 51037a984708SDavid Chisnall{ 51044f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 51057a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 51067a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 51077a984708SDavid Chisnall __partial_sort<_Comp_ref>(__first, __middle, __last, __c); 51084f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 51097a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 51107a984708SDavid Chisnall __partial_sort<_Comp_ref>(__first, __middle, __last, __comp); 51114f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 51127a984708SDavid Chisnall} 51137a984708SDavid Chisnall 51147a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 51157a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51167a984708SDavid Chisnallvoid 51177a984708SDavid Chisnallpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 51187a984708SDavid Chisnall{ 51197a984708SDavid Chisnall _VSTD::partial_sort(__first, __middle, __last, 51207a984708SDavid Chisnall __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 51217a984708SDavid Chisnall} 51227a984708SDavid Chisnall 51237a984708SDavid Chisnall// partial_sort_copy 51247a984708SDavid Chisnall 51257a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator, class _RandomAccessIterator> 51267a984708SDavid Chisnall_RandomAccessIterator 51277a984708SDavid Chisnall__partial_sort_copy(_InputIterator __first, _InputIterator __last, 51287a984708SDavid Chisnall _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 51297a984708SDavid Chisnall{ 51307a984708SDavid Chisnall _RandomAccessIterator __r = __result_first; 51317a984708SDavid Chisnall if (__r != __result_last) 51327a984708SDavid Chisnall { 5133d72607e9SDimitry Andric for (; __first != __last && __r != __result_last; (void) ++__first, ++__r) 51347a984708SDavid Chisnall *__r = *__first; 51357a984708SDavid Chisnall __make_heap<_Compare>(__result_first, __r, __comp); 5136d72607e9SDimitry Andric typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first; 51377a984708SDavid Chisnall for (; __first != __last; ++__first) 51387a984708SDavid Chisnall if (__comp(*__first, *__result_first)) 51397a984708SDavid Chisnall { 51407a984708SDavid Chisnall *__result_first = *__first; 5141d72607e9SDimitry Andric __sift_down<_Compare>(__result_first, __r, __comp, __len, __result_first); 51427a984708SDavid Chisnall } 51437a984708SDavid Chisnall __sort_heap<_Compare>(__result_first, __r, __comp); 51447a984708SDavid Chisnall } 51457a984708SDavid Chisnall return __r; 51467a984708SDavid Chisnall} 51477a984708SDavid Chisnall 51487a984708SDavid Chisnalltemplate <class _InputIterator, class _RandomAccessIterator, class _Compare> 51497a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51507a984708SDavid Chisnall_RandomAccessIterator 51517a984708SDavid Chisnallpartial_sort_copy(_InputIterator __first, _InputIterator __last, 51527a984708SDavid Chisnall _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 51537a984708SDavid Chisnall{ 51544f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 51557a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 51567a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 51577a984708SDavid Chisnall return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c); 51584f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 51597a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 51607a984708SDavid Chisnall return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp); 51614f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 51627a984708SDavid Chisnall} 51637a984708SDavid Chisnall 51647a984708SDavid Chisnalltemplate <class _InputIterator, class _RandomAccessIterator> 51657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51667a984708SDavid Chisnall_RandomAccessIterator 51677a984708SDavid Chisnallpartial_sort_copy(_InputIterator __first, _InputIterator __last, 51687a984708SDavid Chisnall _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) 51697a984708SDavid Chisnall{ 51707a984708SDavid Chisnall return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last, 51717a984708SDavid Chisnall __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 51727a984708SDavid Chisnall} 51737a984708SDavid Chisnall 51747a984708SDavid Chisnall// nth_element 51757a984708SDavid Chisnall 51767a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 51777a984708SDavid Chisnallvoid 51787a984708SDavid Chisnall__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 51797a984708SDavid Chisnall{ 51807a984708SDavid Chisnall // _Compare is known to be a reference type 51817a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 51827a984708SDavid Chisnall const difference_type __limit = 7; 51837a984708SDavid Chisnall while (true) 51847a984708SDavid Chisnall { 51857a984708SDavid Chisnall __restart: 518694e3ee44SDavid Chisnall if (__nth == __last) 518794e3ee44SDavid Chisnall return; 51887a984708SDavid Chisnall difference_type __len = __last - __first; 51897a984708SDavid Chisnall switch (__len) 51907a984708SDavid Chisnall { 51917a984708SDavid Chisnall case 0: 51927a984708SDavid Chisnall case 1: 51937a984708SDavid Chisnall return; 51947a984708SDavid Chisnall case 2: 51957a984708SDavid Chisnall if (__comp(*--__last, *__first)) 51967a984708SDavid Chisnall swap(*__first, *__last); 51977a984708SDavid Chisnall return; 51987a984708SDavid Chisnall case 3: 51997a984708SDavid Chisnall { 52007a984708SDavid Chisnall _RandomAccessIterator __m = __first; 52017a984708SDavid Chisnall _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp); 52027a984708SDavid Chisnall return; 52037a984708SDavid Chisnall } 52047a984708SDavid Chisnall } 52057a984708SDavid Chisnall if (__len <= __limit) 52067a984708SDavid Chisnall { 52077a984708SDavid Chisnall __selection_sort<_Compare>(__first, __last, __comp); 52087a984708SDavid Chisnall return; 52097a984708SDavid Chisnall } 52107a984708SDavid Chisnall // __len > __limit >= 3 52117a984708SDavid Chisnall _RandomAccessIterator __m = __first + __len/2; 52127a984708SDavid Chisnall _RandomAccessIterator __lm1 = __last; 52137a984708SDavid Chisnall unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp); 52147a984708SDavid Chisnall // *__m is median 52157a984708SDavid Chisnall // partition [__first, __m) < *__m and *__m <= [__m, __last) 52167a984708SDavid Chisnall // (this inhibits tossing elements equivalent to __m around unnecessarily) 52177a984708SDavid Chisnall _RandomAccessIterator __i = __first; 52187a984708SDavid Chisnall _RandomAccessIterator __j = __lm1; 52197a984708SDavid Chisnall // j points beyond range to be tested, *__lm1 is known to be <= *__m 52207a984708SDavid Chisnall // The search going up is known to be guarded but the search coming down isn't. 52217a984708SDavid Chisnall // Prime the downward search with a guard. 52227a984708SDavid Chisnall if (!__comp(*__i, *__m)) // if *__first == *__m 52237a984708SDavid Chisnall { 52247a984708SDavid Chisnall // *__first == *__m, *__first doesn't go in first part 52257a984708SDavid Chisnall // manually guard downward moving __j against __i 52267a984708SDavid Chisnall while (true) 52277a984708SDavid Chisnall { 52287a984708SDavid Chisnall if (__i == --__j) 52297a984708SDavid Chisnall { 52307a984708SDavid Chisnall // *__first == *__m, *__m <= all other elements 52317a984708SDavid Chisnall // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 52327a984708SDavid Chisnall ++__i; // __first + 1 52337a984708SDavid Chisnall __j = __last; 52347a984708SDavid Chisnall if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 52357a984708SDavid Chisnall { 52367a984708SDavid Chisnall while (true) 52377a984708SDavid Chisnall { 52387a984708SDavid Chisnall if (__i == __j) 52397a984708SDavid Chisnall return; // [__first, __last) all equivalent elements 52407a984708SDavid Chisnall if (__comp(*__first, *__i)) 52417a984708SDavid Chisnall { 52427a984708SDavid Chisnall swap(*__i, *__j); 52437a984708SDavid Chisnall ++__n_swaps; 52447a984708SDavid Chisnall ++__i; 52457a984708SDavid Chisnall break; 52467a984708SDavid Chisnall } 52477a984708SDavid Chisnall ++__i; 52487a984708SDavid Chisnall } 52497a984708SDavid Chisnall } 52507a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 52517a984708SDavid Chisnall if (__i == __j) 52527a984708SDavid Chisnall return; 52537a984708SDavid Chisnall while (true) 52547a984708SDavid Chisnall { 52557a984708SDavid Chisnall while (!__comp(*__first, *__i)) 52567a984708SDavid Chisnall ++__i; 52577a984708SDavid Chisnall while (__comp(*__first, *--__j)) 52587a984708SDavid Chisnall ; 52597a984708SDavid Chisnall if (__i >= __j) 52607a984708SDavid Chisnall break; 52617a984708SDavid Chisnall swap(*__i, *__j); 52627a984708SDavid Chisnall ++__n_swaps; 52637a984708SDavid Chisnall ++__i; 52647a984708SDavid Chisnall } 52657a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__i, __last) 52667a984708SDavid Chisnall // The first part is sorted, 52677a984708SDavid Chisnall if (__nth < __i) 52687a984708SDavid Chisnall return; 52697a984708SDavid Chisnall // __nth_element the secod part 52707a984708SDavid Chisnall // __nth_element<_Compare>(__i, __nth, __last, __comp); 52717a984708SDavid Chisnall __first = __i; 52727a984708SDavid Chisnall goto __restart; 52737a984708SDavid Chisnall } 52747a984708SDavid Chisnall if (__comp(*__j, *__m)) 52757a984708SDavid Chisnall { 52767a984708SDavid Chisnall swap(*__i, *__j); 52777a984708SDavid Chisnall ++__n_swaps; 52787a984708SDavid Chisnall break; // found guard for downward moving __j, now use unguarded partition 52797a984708SDavid Chisnall } 52807a984708SDavid Chisnall } 52817a984708SDavid Chisnall } 52827a984708SDavid Chisnall ++__i; 52837a984708SDavid Chisnall // j points beyond range to be tested, *__lm1 is known to be <= *__m 52847a984708SDavid Chisnall // if not yet partitioned... 52857a984708SDavid Chisnall if (__i < __j) 52867a984708SDavid Chisnall { 52877a984708SDavid Chisnall // known that *(__i - 1) < *__m 52887a984708SDavid Chisnall while (true) 52897a984708SDavid Chisnall { 52907a984708SDavid Chisnall // __m still guards upward moving __i 52917a984708SDavid Chisnall while (__comp(*__i, *__m)) 52927a984708SDavid Chisnall ++__i; 52937a984708SDavid Chisnall // It is now known that a guard exists for downward moving __j 52947a984708SDavid Chisnall while (!__comp(*--__j, *__m)) 52957a984708SDavid Chisnall ; 52967a984708SDavid Chisnall if (__i >= __j) 52977a984708SDavid Chisnall break; 52987a984708SDavid Chisnall swap(*__i, *__j); 52997a984708SDavid Chisnall ++__n_swaps; 53007a984708SDavid Chisnall // It is known that __m != __j 53017a984708SDavid Chisnall // If __m just moved, follow it 53027a984708SDavid Chisnall if (__m == __i) 53037a984708SDavid Chisnall __m = __j; 53047a984708SDavid Chisnall ++__i; 53057a984708SDavid Chisnall } 53067a984708SDavid Chisnall } 53077a984708SDavid Chisnall // [__first, __i) < *__m and *__m <= [__i, __last) 53087a984708SDavid Chisnall if (__i != __m && __comp(*__m, *__i)) 53097a984708SDavid Chisnall { 53107a984708SDavid Chisnall swap(*__i, *__m); 53117a984708SDavid Chisnall ++__n_swaps; 53127a984708SDavid Chisnall } 53137a984708SDavid Chisnall // [__first, __i) < *__i and *__i <= [__i+1, __last) 53147a984708SDavid Chisnall if (__nth == __i) 53157a984708SDavid Chisnall return; 53167a984708SDavid Chisnall if (__n_swaps == 0) 53177a984708SDavid Chisnall { 53187a984708SDavid Chisnall // We were given a perfectly partitioned sequence. Coincidence? 53197a984708SDavid Chisnall if (__nth < __i) 53207a984708SDavid Chisnall { 53217a984708SDavid Chisnall // Check for [__first, __i) already sorted 53227a984708SDavid Chisnall __j = __m = __first; 53237a984708SDavid Chisnall while (++__j != __i) 53247a984708SDavid Chisnall { 53257a984708SDavid Chisnall if (__comp(*__j, *__m)) 53267a984708SDavid Chisnall // not yet sorted, so sort 53277a984708SDavid Chisnall goto not_sorted; 53287a984708SDavid Chisnall __m = __j; 53297a984708SDavid Chisnall } 53307a984708SDavid Chisnall // [__first, __i) sorted 53317a984708SDavid Chisnall return; 53327a984708SDavid Chisnall } 53337a984708SDavid Chisnall else 53347a984708SDavid Chisnall { 53357a984708SDavid Chisnall // Check for [__i, __last) already sorted 53367a984708SDavid Chisnall __j = __m = __i; 53377a984708SDavid Chisnall while (++__j != __last) 53387a984708SDavid Chisnall { 53397a984708SDavid Chisnall if (__comp(*__j, *__m)) 53407a984708SDavid Chisnall // not yet sorted, so sort 53417a984708SDavid Chisnall goto not_sorted; 53427a984708SDavid Chisnall __m = __j; 53437a984708SDavid Chisnall } 53447a984708SDavid Chisnall // [__i, __last) sorted 53457a984708SDavid Chisnall return; 53467a984708SDavid Chisnall } 53477a984708SDavid Chisnall } 53487a984708SDavid Chisnallnot_sorted: 53497a984708SDavid Chisnall // __nth_element on range containing __nth 53507a984708SDavid Chisnall if (__nth < __i) 53517a984708SDavid Chisnall { 53527a984708SDavid Chisnall // __nth_element<_Compare>(__first, __nth, __i, __comp); 53537a984708SDavid Chisnall __last = __i; 53547a984708SDavid Chisnall } 53557a984708SDavid Chisnall else 53567a984708SDavid Chisnall { 53577a984708SDavid Chisnall // __nth_element<_Compare>(__i+1, __nth, __last, __comp); 53587a984708SDavid Chisnall __first = ++__i; 53597a984708SDavid Chisnall } 53607a984708SDavid Chisnall } 53617a984708SDavid Chisnall} 53627a984708SDavid Chisnall 53637a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 53647a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 53657a984708SDavid Chisnallvoid 53667a984708SDavid Chisnallnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 53677a984708SDavid Chisnall{ 53684f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 53697a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 53707a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 53717a984708SDavid Chisnall __nth_element<_Comp_ref>(__first, __nth, __last, __c); 53724f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 53737a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 53747a984708SDavid Chisnall __nth_element<_Comp_ref>(__first, __nth, __last, __comp); 53754f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 53767a984708SDavid Chisnall} 53777a984708SDavid Chisnall 53787a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 53797a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 53807a984708SDavid Chisnallvoid 53817a984708SDavid Chisnallnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) 53827a984708SDavid Chisnall{ 53837a984708SDavid Chisnall _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 53847a984708SDavid Chisnall} 53857a984708SDavid Chisnall 53867a984708SDavid Chisnall// includes 53877a984708SDavid Chisnall 53887a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2> 53897a984708SDavid Chisnallbool 53907a984708SDavid Chisnall__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 53917a984708SDavid Chisnall _Compare __comp) 53927a984708SDavid Chisnall{ 53937a984708SDavid Chisnall for (; __first2 != __last2; ++__first1) 53947a984708SDavid Chisnall { 53957a984708SDavid Chisnall if (__first1 == __last1 || __comp(*__first2, *__first1)) 53967a984708SDavid Chisnall return false; 53977a984708SDavid Chisnall if (!__comp(*__first1, *__first2)) 53987a984708SDavid Chisnall ++__first2; 53997a984708SDavid Chisnall } 54007a984708SDavid Chisnall return true; 54017a984708SDavid Chisnall} 54027a984708SDavid Chisnall 54037a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _Compare> 54047a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54057a984708SDavid Chisnallbool 54067a984708SDavid Chisnallincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 54077a984708SDavid Chisnall _Compare __comp) 54087a984708SDavid Chisnall{ 54094f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 54107a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 54117a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 54127a984708SDavid Chisnall return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 54134f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 54147a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 54157a984708SDavid Chisnall return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 54164f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 54177a984708SDavid Chisnall} 54187a984708SDavid Chisnall 54197a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 54207a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54217a984708SDavid Chisnallbool 54227a984708SDavid Chisnallincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) 54237a984708SDavid Chisnall{ 54247a984708SDavid Chisnall return _VSTD::includes(__first1, __last1, __first2, __last2, 54257a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 54267a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 54277a984708SDavid Chisnall} 54287a984708SDavid Chisnall 54297a984708SDavid Chisnall// set_union 54307a984708SDavid Chisnall 54317a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 54327a984708SDavid Chisnall_OutputIterator 54337a984708SDavid Chisnall__set_union(_InputIterator1 __first1, _InputIterator1 __last1, 54347a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 54357a984708SDavid Chisnall{ 54367a984708SDavid Chisnall for (; __first1 != __last1; ++__result) 54377a984708SDavid Chisnall { 54387a984708SDavid Chisnall if (__first2 == __last2) 54397a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 54407a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 54417a984708SDavid Chisnall { 54427a984708SDavid Chisnall *__result = *__first2; 54437a984708SDavid Chisnall ++__first2; 54447a984708SDavid Chisnall } 54457a984708SDavid Chisnall else 54467a984708SDavid Chisnall { 54477a984708SDavid Chisnall *__result = *__first1; 54487a984708SDavid Chisnall if (!__comp(*__first1, *__first2)) 54497a984708SDavid Chisnall ++__first2; 54507a984708SDavid Chisnall ++__first1; 54517a984708SDavid Chisnall } 54527a984708SDavid Chisnall } 54537a984708SDavid Chisnall return _VSTD::copy(__first2, __last2, __result); 54547a984708SDavid Chisnall} 54557a984708SDavid Chisnall 54567a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 54577a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54587a984708SDavid Chisnall_OutputIterator 54597a984708SDavid Chisnallset_union(_InputIterator1 __first1, _InputIterator1 __last1, 54607a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 54617a984708SDavid Chisnall{ 54624f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 54637a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 54647a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 54657a984708SDavid Chisnall return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 54664f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 54677a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 54687a984708SDavid Chisnall return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 54694f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 54707a984708SDavid Chisnall} 54717a984708SDavid Chisnall 54727a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 54737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54747a984708SDavid Chisnall_OutputIterator 54757a984708SDavid Chisnallset_union(_InputIterator1 __first1, _InputIterator1 __last1, 54767a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 54777a984708SDavid Chisnall{ 54787a984708SDavid Chisnall return _VSTD::set_union(__first1, __last1, __first2, __last2, __result, 54797a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 54807a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 54817a984708SDavid Chisnall} 54827a984708SDavid Chisnall 54837a984708SDavid Chisnall// set_intersection 54847a984708SDavid Chisnall 54857a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 54867a984708SDavid Chisnall_OutputIterator 54877a984708SDavid Chisnall__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 54887a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 54897a984708SDavid Chisnall{ 54907a984708SDavid Chisnall while (__first1 != __last1 && __first2 != __last2) 54917a984708SDavid Chisnall { 54927a984708SDavid Chisnall if (__comp(*__first1, *__first2)) 54937a984708SDavid Chisnall ++__first1; 54947a984708SDavid Chisnall else 54957a984708SDavid Chisnall { 54967a984708SDavid Chisnall if (!__comp(*__first2, *__first1)) 54977a984708SDavid Chisnall { 54987a984708SDavid Chisnall *__result = *__first1; 54997a984708SDavid Chisnall ++__result; 55007a984708SDavid Chisnall ++__first1; 55017a984708SDavid Chisnall } 55027a984708SDavid Chisnall ++__first2; 55037a984708SDavid Chisnall } 55047a984708SDavid Chisnall } 55057a984708SDavid Chisnall return __result; 55067a984708SDavid Chisnall} 55077a984708SDavid Chisnall 55087a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 55097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 55107a984708SDavid Chisnall_OutputIterator 55117a984708SDavid Chisnallset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 55127a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 55137a984708SDavid Chisnall{ 55144f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 55157a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 55167a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 55177a984708SDavid Chisnall return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 55184f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 55197a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 55207a984708SDavid Chisnall return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 55214f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 55227a984708SDavid Chisnall} 55237a984708SDavid Chisnall 55247a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 55257a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 55267a984708SDavid Chisnall_OutputIterator 55277a984708SDavid Chisnallset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 55287a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 55297a984708SDavid Chisnall{ 55307a984708SDavid Chisnall return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result, 55317a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 55327a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 55337a984708SDavid Chisnall} 55347a984708SDavid Chisnall 55357a984708SDavid Chisnall// set_difference 55367a984708SDavid Chisnall 55377a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 55387a984708SDavid Chisnall_OutputIterator 55397a984708SDavid Chisnall__set_difference(_InputIterator1 __first1, _InputIterator1 __last1, 55407a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 55417a984708SDavid Chisnall{ 55427a984708SDavid Chisnall while (__first1 != __last1) 55437a984708SDavid Chisnall { 55447a984708SDavid Chisnall if (__first2 == __last2) 55457a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 55467a984708SDavid Chisnall if (__comp(*__first1, *__first2)) 55477a984708SDavid Chisnall { 55487a984708SDavid Chisnall *__result = *__first1; 55497a984708SDavid Chisnall ++__result; 55507a984708SDavid Chisnall ++__first1; 55517a984708SDavid Chisnall } 55527a984708SDavid Chisnall else 55537a984708SDavid Chisnall { 55547a984708SDavid Chisnall if (!__comp(*__first2, *__first1)) 55557a984708SDavid Chisnall ++__first1; 55567a984708SDavid Chisnall ++__first2; 55577a984708SDavid Chisnall } 55587a984708SDavid Chisnall } 55597a984708SDavid Chisnall return __result; 55607a984708SDavid Chisnall} 55617a984708SDavid Chisnall 55627a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 55637a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 55647a984708SDavid Chisnall_OutputIterator 55657a984708SDavid Chisnallset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 55667a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 55677a984708SDavid Chisnall{ 55684f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 55697a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 55707a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 55717a984708SDavid Chisnall return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 55724f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 55737a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 55747a984708SDavid Chisnall return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 55754f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 55767a984708SDavid Chisnall} 55777a984708SDavid Chisnall 55787a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 55797a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 55807a984708SDavid Chisnall_OutputIterator 55817a984708SDavid Chisnallset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 55827a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 55837a984708SDavid Chisnall{ 55847a984708SDavid Chisnall return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result, 55857a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 55867a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 55877a984708SDavid Chisnall} 55887a984708SDavid Chisnall 55897a984708SDavid Chisnall// set_symmetric_difference 55907a984708SDavid Chisnall 55917a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 55927a984708SDavid Chisnall_OutputIterator 55937a984708SDavid Chisnall__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 55947a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 55957a984708SDavid Chisnall{ 55967a984708SDavid Chisnall while (__first1 != __last1) 55977a984708SDavid Chisnall { 55987a984708SDavid Chisnall if (__first2 == __last2) 55997a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 56007a984708SDavid Chisnall if (__comp(*__first1, *__first2)) 56017a984708SDavid Chisnall { 56027a984708SDavid Chisnall *__result = *__first1; 56037a984708SDavid Chisnall ++__result; 56047a984708SDavid Chisnall ++__first1; 56057a984708SDavid Chisnall } 56067a984708SDavid Chisnall else 56077a984708SDavid Chisnall { 56087a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 56097a984708SDavid Chisnall { 56107a984708SDavid Chisnall *__result = *__first2; 56117a984708SDavid Chisnall ++__result; 56127a984708SDavid Chisnall } 56137a984708SDavid Chisnall else 56147a984708SDavid Chisnall ++__first1; 56157a984708SDavid Chisnall ++__first2; 56167a984708SDavid Chisnall } 56177a984708SDavid Chisnall } 56187a984708SDavid Chisnall return _VSTD::copy(__first2, __last2, __result); 56197a984708SDavid Chisnall} 56207a984708SDavid Chisnall 56217a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 56227a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 56237a984708SDavid Chisnall_OutputIterator 56247a984708SDavid Chisnallset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 56257a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 56267a984708SDavid Chisnall{ 56274f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 56287a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 56297a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 56307a984708SDavid Chisnall return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 56314f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 56327a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 56337a984708SDavid Chisnall return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 56344f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 56357a984708SDavid Chisnall} 56367a984708SDavid Chisnall 56377a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 56387a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 56397a984708SDavid Chisnall_OutputIterator 56407a984708SDavid Chisnallset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 56417a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 56427a984708SDavid Chisnall{ 56437a984708SDavid Chisnall return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, 56447a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 56457a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 56467a984708SDavid Chisnall} 56477a984708SDavid Chisnall 56487a984708SDavid Chisnall// lexicographical_compare 56497a984708SDavid Chisnall 56507a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2> 56517a984708SDavid Chisnallbool 56527a984708SDavid Chisnall__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 56537a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 56547a984708SDavid Chisnall{ 5655d72607e9SDimitry Andric for (; __first2 != __last2; ++__first1, (void) ++__first2) 56567a984708SDavid Chisnall { 56577a984708SDavid Chisnall if (__first1 == __last1 || __comp(*__first1, *__first2)) 56587a984708SDavid Chisnall return true; 56597a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 56607a984708SDavid Chisnall return false; 56617a984708SDavid Chisnall } 56627a984708SDavid Chisnall return false; 56637a984708SDavid Chisnall} 56647a984708SDavid Chisnall 56657a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _Compare> 56667a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 56677a984708SDavid Chisnallbool 56687a984708SDavid Chisnalllexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 56697a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 56707a984708SDavid Chisnall{ 56714f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 56727a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 56737a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 56747a984708SDavid Chisnall return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 56754f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 56767a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 56777a984708SDavid Chisnall return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 56784f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 56797a984708SDavid Chisnall} 56807a984708SDavid Chisnall 56817a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 56827a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 56837a984708SDavid Chisnallbool 56847a984708SDavid Chisnalllexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 56857a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2) 56867a984708SDavid Chisnall{ 56877a984708SDavid Chisnall return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2, 56887a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 56897a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 56907a984708SDavid Chisnall} 56917a984708SDavid Chisnall 56927a984708SDavid Chisnall// next_permutation 56937a984708SDavid Chisnall 56947a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 56957a984708SDavid Chisnallbool 56967a984708SDavid Chisnall__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 56977a984708SDavid Chisnall{ 56987a984708SDavid Chisnall _BidirectionalIterator __i = __last; 56997a984708SDavid Chisnall if (__first == __last || __first == --__i) 57007a984708SDavid Chisnall return false; 57017a984708SDavid Chisnall while (true) 57027a984708SDavid Chisnall { 57037a984708SDavid Chisnall _BidirectionalIterator __ip1 = __i; 57047a984708SDavid Chisnall if (__comp(*--__i, *__ip1)) 57057a984708SDavid Chisnall { 57067a984708SDavid Chisnall _BidirectionalIterator __j = __last; 57077a984708SDavid Chisnall while (!__comp(*__i, *--__j)) 57087a984708SDavid Chisnall ; 57097a984708SDavid Chisnall swap(*__i, *__j); 57107a984708SDavid Chisnall _VSTD::reverse(__ip1, __last); 57117a984708SDavid Chisnall return true; 57127a984708SDavid Chisnall } 57137a984708SDavid Chisnall if (__i == __first) 57147a984708SDavid Chisnall { 57157a984708SDavid Chisnall _VSTD::reverse(__first, __last); 57167a984708SDavid Chisnall return false; 57177a984708SDavid Chisnall } 57187a984708SDavid Chisnall } 57197a984708SDavid Chisnall} 57207a984708SDavid Chisnall 57217a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare> 57227a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 57237a984708SDavid Chisnallbool 57247a984708SDavid Chisnallnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 57257a984708SDavid Chisnall{ 57264f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 57277a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 57287a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 57297a984708SDavid Chisnall return __next_permutation<_Comp_ref>(__first, __last, __c); 57304f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 57317a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 57327a984708SDavid Chisnall return __next_permutation<_Comp_ref>(__first, __last, __comp); 57334f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 57347a984708SDavid Chisnall} 57357a984708SDavid Chisnall 57367a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 57377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 57387a984708SDavid Chisnallbool 57397a984708SDavid Chisnallnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 57407a984708SDavid Chisnall{ 57417a984708SDavid Chisnall return _VSTD::next_permutation(__first, __last, 57427a984708SDavid Chisnall __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 57437a984708SDavid Chisnall} 57447a984708SDavid Chisnall 57457a984708SDavid Chisnall// prev_permutation 57467a984708SDavid Chisnall 57477a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 57487a984708SDavid Chisnallbool 57497a984708SDavid Chisnall__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 57507a984708SDavid Chisnall{ 57517a984708SDavid Chisnall _BidirectionalIterator __i = __last; 57527a984708SDavid Chisnall if (__first == __last || __first == --__i) 57537a984708SDavid Chisnall return false; 57547a984708SDavid Chisnall while (true) 57557a984708SDavid Chisnall { 57567a984708SDavid Chisnall _BidirectionalIterator __ip1 = __i; 57577a984708SDavid Chisnall if (__comp(*__ip1, *--__i)) 57587a984708SDavid Chisnall { 57597a984708SDavid Chisnall _BidirectionalIterator __j = __last; 57607a984708SDavid Chisnall while (!__comp(*--__j, *__i)) 57617a984708SDavid Chisnall ; 57627a984708SDavid Chisnall swap(*__i, *__j); 57637a984708SDavid Chisnall _VSTD::reverse(__ip1, __last); 57647a984708SDavid Chisnall return true; 57657a984708SDavid Chisnall } 57667a984708SDavid Chisnall if (__i == __first) 57677a984708SDavid Chisnall { 57687a984708SDavid Chisnall _VSTD::reverse(__first, __last); 57697a984708SDavid Chisnall return false; 57707a984708SDavid Chisnall } 57717a984708SDavid Chisnall } 57727a984708SDavid Chisnall} 57737a984708SDavid Chisnall 57747a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare> 57757a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 57767a984708SDavid Chisnallbool 57777a984708SDavid Chisnallprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 57787a984708SDavid Chisnall{ 57794f7ab58eSDimitry Andric#ifdef _LIBCPP_DEBUG 57807a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 57817a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 57827a984708SDavid Chisnall return __prev_permutation<_Comp_ref>(__first, __last, __c); 57834f7ab58eSDimitry Andric#else // _LIBCPP_DEBUG 57847a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 57857a984708SDavid Chisnall return __prev_permutation<_Comp_ref>(__first, __last, __comp); 57864f7ab58eSDimitry Andric#endif // _LIBCPP_DEBUG 57877a984708SDavid Chisnall} 57887a984708SDavid Chisnall 57897a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 57907a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 57917a984708SDavid Chisnallbool 57927a984708SDavid Chisnallprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 57937a984708SDavid Chisnall{ 57947a984708SDavid Chisnall return _VSTD::prev_permutation(__first, __last, 57957a984708SDavid Chisnall __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 57967a984708SDavid Chisnall} 57977a984708SDavid Chisnall 57987a984708SDavid Chisnall_LIBCPP_END_NAMESPACE_STD 57997a984708SDavid Chisnall 58007a984708SDavid Chisnall#endif // _LIBCPP_ALGORITHM 5801