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 907a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 917a984708SDavid Chisnall pair<InputIterator1, InputIterator2> 927a984708SDavid Chisnall mismatch(InputIterator1 first1, InputIterator1 last1, 937a984708SDavid Chisnall InputIterator2 first2, BinaryPredicate pred); 947a984708SDavid Chisnall 957a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 967a984708SDavid Chisnall bool 977a984708SDavid Chisnall equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 987a984708SDavid Chisnall 997a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 1007a984708SDavid Chisnall bool 1017a984708SDavid Chisnall equal(InputIterator1 first1, InputIterator1 last1, 1027a984708SDavid Chisnall InputIterator2 first2, BinaryPredicate pred); 1037a984708SDavid Chisnall 1047a984708SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2> 1057a984708SDavid Chisnall bool 1067a984708SDavid Chisnall is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 1077a984708SDavid Chisnall ForwardIterator2 first2); 1087a984708SDavid Chisnall 1097a984708SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 1107a984708SDavid Chisnall bool 1117a984708SDavid Chisnall is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 1127a984708SDavid Chisnall ForwardIterator2 first2, BinaryPredicate pred); 1137a984708SDavid Chisnall 1147a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 1157a984708SDavid Chisnall ForwardIterator1 1167a984708SDavid Chisnall search(ForwardIterator1 first1, ForwardIterator1 last1, 1177a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2); 1187a984708SDavid Chisnall 1197a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 1207a984708SDavid Chisnall ForwardIterator1 1217a984708SDavid Chisnall search(ForwardIterator1 first1, ForwardIterator1 last1, 1227a984708SDavid Chisnall ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 1237a984708SDavid Chisnall 1247a984708SDavid Chisnalltemplate <class ForwardIterator, class Size, class T> 1257a984708SDavid Chisnall ForwardIterator 1267a984708SDavid Chisnall search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); 1277a984708SDavid Chisnall 1287a984708SDavid Chisnalltemplate <class ForwardIterator, class Size, class T, class BinaryPredicate> 1297a984708SDavid Chisnall ForwardIterator 1307a984708SDavid Chisnall search_n(ForwardIterator first, ForwardIterator last, 1317a984708SDavid Chisnall Size count, const T& value, BinaryPredicate pred); 1327a984708SDavid Chisnall 1337a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator> 1347a984708SDavid Chisnall OutputIterator 1357a984708SDavid Chisnall copy(InputIterator first, InputIterator last, OutputIterator result); 1367a984708SDavid Chisnall 1377a984708SDavid Chisnalltemplate<class InputIterator, class OutputIterator, class Predicate> 1387a984708SDavid Chisnall OutputIterator 1397a984708SDavid Chisnall copy_if(InputIterator first, InputIterator last, 1407a984708SDavid Chisnall OutputIterator result, Predicate pred); 1417a984708SDavid Chisnall 1427a984708SDavid Chisnalltemplate<class InputIterator, class Size, class OutputIterator> 1437a984708SDavid Chisnall OutputIterator 1447a984708SDavid Chisnall copy_n(InputIterator first, Size n, OutputIterator result); 1457a984708SDavid Chisnall 1467a984708SDavid Chisnalltemplate <class BidirectionalIterator1, class BidirectionalIterator2> 1477a984708SDavid Chisnall BidirectionalIterator2 1487a984708SDavid Chisnall copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 1497a984708SDavid Chisnall BidirectionalIterator2 result); 1507a984708SDavid Chisnall 1517a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 1527a984708SDavid Chisnall ForwardIterator2 1537a984708SDavid Chisnall swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); 1547a984708SDavid Chisnall 1557a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2> 1567a984708SDavid Chisnall void 1577a984708SDavid Chisnall iter_swap(ForwardIterator1 a, ForwardIterator2 b); 1587a984708SDavid Chisnall 1597a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class UnaryOperation> 1607a984708SDavid Chisnall OutputIterator 1617a984708SDavid Chisnall transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); 1627a984708SDavid Chisnall 1637a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> 1647a984708SDavid Chisnall OutputIterator 1657a984708SDavid Chisnall transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, 1667a984708SDavid Chisnall OutputIterator result, BinaryOperation binary_op); 1677a984708SDavid Chisnall 1687a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 1697a984708SDavid Chisnall void 1707a984708SDavid Chisnall replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); 1717a984708SDavid Chisnall 1727a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate, class T> 1737a984708SDavid Chisnall void 1747a984708SDavid Chisnall replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); 1757a984708SDavid Chisnall 1767a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class T> 1777a984708SDavid Chisnall OutputIterator 1787a984708SDavid Chisnall replace_copy(InputIterator first, InputIterator last, OutputIterator result, 1797a984708SDavid Chisnall const T& old_value, const T& new_value); 1807a984708SDavid Chisnall 1817a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class Predicate, class T> 1827a984708SDavid Chisnall OutputIterator 1837a984708SDavid Chisnall replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value); 1847a984708SDavid Chisnall 1857a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 1867a984708SDavid Chisnall void 1877a984708SDavid Chisnall fill(ForwardIterator first, ForwardIterator last, const T& value); 1887a984708SDavid Chisnall 1897a984708SDavid Chisnalltemplate <class OutputIterator, class Size, class T> 1907a984708SDavid Chisnall OutputIterator 1917a984708SDavid Chisnall fill_n(OutputIterator first, Size n, const T& value); 1927a984708SDavid Chisnall 1937a984708SDavid Chisnalltemplate <class ForwardIterator, class Generator> 1947a984708SDavid Chisnall void 1957a984708SDavid Chisnall generate(ForwardIterator first, ForwardIterator last, Generator gen); 1967a984708SDavid Chisnall 1977a984708SDavid Chisnalltemplate <class OutputIterator, class Size, class Generator> 1987a984708SDavid Chisnall OutputIterator 1997a984708SDavid Chisnall generate_n(OutputIterator first, Size n, Generator gen); 2007a984708SDavid Chisnall 2017a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 2027a984708SDavid Chisnall ForwardIterator 2037a984708SDavid Chisnall remove(ForwardIterator first, ForwardIterator last, const T& value); 2047a984708SDavid Chisnall 2057a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate> 2067a984708SDavid Chisnall ForwardIterator 2077a984708SDavid Chisnall remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); 2087a984708SDavid Chisnall 2097a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class T> 2107a984708SDavid Chisnall OutputIterator 2117a984708SDavid Chisnall remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); 2127a984708SDavid Chisnall 2137a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class Predicate> 2147a984708SDavid Chisnall OutputIterator 2157a984708SDavid Chisnall remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); 2167a984708SDavid Chisnall 2177a984708SDavid Chisnalltemplate <class ForwardIterator> 2187a984708SDavid Chisnall ForwardIterator 2197a984708SDavid Chisnall unique(ForwardIterator first, ForwardIterator last); 2207a984708SDavid Chisnall 2217a984708SDavid Chisnalltemplate <class ForwardIterator, class BinaryPredicate> 2227a984708SDavid Chisnall ForwardIterator 2237a984708SDavid Chisnall unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 2247a984708SDavid Chisnall 2257a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator> 2267a984708SDavid Chisnall OutputIterator 2277a984708SDavid Chisnall unique_copy(InputIterator first, InputIterator last, OutputIterator result); 2287a984708SDavid Chisnall 2297a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class BinaryPredicate> 2307a984708SDavid Chisnall OutputIterator 2317a984708SDavid Chisnall unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); 2327a984708SDavid Chisnall 2337a984708SDavid Chisnalltemplate <class BidirectionalIterator> 2347a984708SDavid Chisnall void 2357a984708SDavid Chisnall reverse(BidirectionalIterator first, BidirectionalIterator last); 2367a984708SDavid Chisnall 2377a984708SDavid Chisnalltemplate <class BidirectionalIterator, class OutputIterator> 2387a984708SDavid Chisnall OutputIterator 2397a984708SDavid Chisnall reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); 2407a984708SDavid Chisnall 2417a984708SDavid Chisnalltemplate <class ForwardIterator> 2427a984708SDavid Chisnall ForwardIterator 2437a984708SDavid Chisnall rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); 2447a984708SDavid Chisnall 2457a984708SDavid Chisnalltemplate <class ForwardIterator, class OutputIterator> 2467a984708SDavid Chisnall OutputIterator 2477a984708SDavid Chisnall rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); 2487a984708SDavid Chisnall 2497a984708SDavid Chisnalltemplate <class RandomAccessIterator> 2507a984708SDavid Chisnall void 2517a984708SDavid Chisnall random_shuffle(RandomAccessIterator first, RandomAccessIterator last); 2527a984708SDavid Chisnall 2537a984708SDavid Chisnalltemplate <class RandomAccessIterator, class RandomNumberGenerator> 2547a984708SDavid Chisnall void 2557a984708SDavid Chisnall random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand); 2567a984708SDavid Chisnall 2577a984708SDavid Chisnalltemplate<class RandomAccessIterator, class UniformRandomNumberGenerator> 2587a984708SDavid Chisnall void shuffle(RandomAccessIterator first, RandomAccessIterator last, 2597a984708SDavid Chisnall UniformRandomNumberGenerator&& g); 2607a984708SDavid Chisnall 2617a984708SDavid Chisnalltemplate <class InputIterator, class Predicate> 2627a984708SDavid Chisnall bool 2637a984708SDavid Chisnall is_partitioned(InputIterator first, InputIterator last, Predicate pred); 2647a984708SDavid Chisnall 2657a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate> 2667a984708SDavid Chisnall ForwardIterator 2677a984708SDavid Chisnall partition(ForwardIterator first, ForwardIterator last, Predicate pred); 2687a984708SDavid Chisnall 2697a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator1, 2707a984708SDavid Chisnall class OutputIterator2, class Predicate> 2717a984708SDavid Chisnall pair<OutputIterator1, OutputIterator2> 2727a984708SDavid Chisnall partition_copy(InputIterator first, InputIterator last, 2737a984708SDavid Chisnall OutputIterator1 out_true, OutputIterator2 out_false, 2747a984708SDavid Chisnall Predicate pred); 2757a984708SDavid Chisnall 2767a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate> 2777a984708SDavid Chisnall ForwardIterator 2787a984708SDavid Chisnall stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred); 2797a984708SDavid Chisnall 2807a984708SDavid Chisnalltemplate<class ForwardIterator, class Predicate> 2817a984708SDavid Chisnall ForwardIterator 2827a984708SDavid Chisnall partition_point(ForwardIterator first, ForwardIterator last, Predicate pred); 2837a984708SDavid Chisnall 2847a984708SDavid Chisnalltemplate <class ForwardIterator> 2857a984708SDavid Chisnall bool 2867a984708SDavid Chisnall is_sorted(ForwardIterator first, ForwardIterator last); 2877a984708SDavid Chisnall 2887a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 2897a984708SDavid Chisnall bool 2907a984708SDavid Chisnall is_sorted(ForwardIterator first, ForwardIterator last, Compare comp); 2917a984708SDavid Chisnall 2927a984708SDavid Chisnalltemplate<class ForwardIterator> 2937a984708SDavid Chisnall ForwardIterator 2947a984708SDavid Chisnall is_sorted_until(ForwardIterator first, ForwardIterator last); 2957a984708SDavid Chisnall 2967a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 2977a984708SDavid Chisnall ForwardIterator 2987a984708SDavid Chisnall is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp); 2997a984708SDavid Chisnall 3007a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3017a984708SDavid Chisnall void 3027a984708SDavid Chisnall sort(RandomAccessIterator first, RandomAccessIterator last); 3037a984708SDavid Chisnall 3047a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3057a984708SDavid Chisnall void 3067a984708SDavid Chisnall sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 3077a984708SDavid Chisnall 3087a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3097a984708SDavid Chisnall void 3107a984708SDavid Chisnall stable_sort(RandomAccessIterator first, RandomAccessIterator last); 3117a984708SDavid Chisnall 3127a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3137a984708SDavid Chisnall void 3147a984708SDavid Chisnall stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 3157a984708SDavid Chisnall 3167a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3177a984708SDavid Chisnall void 3187a984708SDavid Chisnall partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); 3197a984708SDavid Chisnall 3207a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3217a984708SDavid Chisnall void 3227a984708SDavid Chisnall partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); 3237a984708SDavid Chisnall 3247a984708SDavid Chisnalltemplate <class InputIterator, class RandomAccessIterator> 3257a984708SDavid Chisnall RandomAccessIterator 3267a984708SDavid Chisnall partial_sort_copy(InputIterator first, InputIterator last, 3277a984708SDavid Chisnall RandomAccessIterator result_first, RandomAccessIterator result_last); 3287a984708SDavid Chisnall 3297a984708SDavid Chisnalltemplate <class InputIterator, class RandomAccessIterator, class Compare> 3307a984708SDavid Chisnall RandomAccessIterator 3317a984708SDavid Chisnall partial_sort_copy(InputIterator first, InputIterator last, 3327a984708SDavid Chisnall RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); 3337a984708SDavid Chisnall 3347a984708SDavid Chisnalltemplate <class RandomAccessIterator> 3357a984708SDavid Chisnall void 3367a984708SDavid Chisnall nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); 3377a984708SDavid Chisnall 3387a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 3397a984708SDavid Chisnall void 3407a984708SDavid Chisnall nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); 3417a984708SDavid Chisnall 3427a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3437a984708SDavid Chisnall ForwardIterator 3447a984708SDavid Chisnall lower_bound(ForwardIterator first, ForwardIterator last, const T& value); 3457a984708SDavid Chisnall 3467a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 3477a984708SDavid Chisnall ForwardIterator 3487a984708SDavid Chisnall lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 3497a984708SDavid Chisnall 3507a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3517a984708SDavid Chisnall ForwardIterator 3527a984708SDavid Chisnall upper_bound(ForwardIterator first, ForwardIterator last, const T& value); 3537a984708SDavid Chisnall 3547a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 3557a984708SDavid Chisnall ForwardIterator 3567a984708SDavid Chisnall upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 3577a984708SDavid Chisnall 3587a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3597a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 3607a984708SDavid Chisnall equal_range(ForwardIterator first, ForwardIterator last, const T& value); 3617a984708SDavid Chisnall 3627a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 3637a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 3647a984708SDavid Chisnall equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 3657a984708SDavid Chisnall 3667a984708SDavid Chisnalltemplate <class ForwardIterator, class T> 3677a984708SDavid Chisnall bool 3687a984708SDavid Chisnall binary_search(ForwardIterator first, ForwardIterator last, const T& value); 3697a984708SDavid Chisnall 3707a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare> 3717a984708SDavid Chisnall bool 3727a984708SDavid Chisnall binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 3737a984708SDavid Chisnall 3747a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 3757a984708SDavid Chisnall OutputIterator 3767a984708SDavid Chisnall merge(InputIterator1 first1, InputIterator1 last1, 3777a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 3787a984708SDavid Chisnall 3797a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 3807a984708SDavid Chisnall OutputIterator 3817a984708SDavid Chisnall merge(InputIterator1 first1, InputIterator1 last1, 3827a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 3837a984708SDavid Chisnall 3847a984708SDavid Chisnalltemplate <class BidirectionalIterator> 3857a984708SDavid Chisnall void 3867a984708SDavid Chisnall inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); 3877a984708SDavid Chisnall 3887a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare> 3897a984708SDavid Chisnall void 3907a984708SDavid Chisnall inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); 3917a984708SDavid Chisnall 3927a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 3937a984708SDavid Chisnall bool 3947a984708SDavid Chisnall includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 3957a984708SDavid Chisnall 3967a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class Compare> 3977a984708SDavid Chisnall bool 3987a984708SDavid Chisnall includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); 3997a984708SDavid Chisnall 4007a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4017a984708SDavid Chisnall OutputIterator 4027a984708SDavid Chisnall set_union(InputIterator1 first1, InputIterator1 last1, 4037a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4047a984708SDavid Chisnall 4057a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4067a984708SDavid Chisnall OutputIterator 4077a984708SDavid Chisnall set_union(InputIterator1 first1, InputIterator1 last1, 4087a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4097a984708SDavid Chisnall 4107a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4117a984708SDavid Chisnall OutputIterator 4127a984708SDavid Chisnall set_intersection(InputIterator1 first1, InputIterator1 last1, 4137a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4147a984708SDavid Chisnall 4157a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4167a984708SDavid Chisnall OutputIterator 4177a984708SDavid Chisnall set_intersection(InputIterator1 first1, InputIterator1 last1, 4187a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4197a984708SDavid Chisnall 4207a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4217a984708SDavid Chisnall OutputIterator 4227a984708SDavid Chisnall set_difference(InputIterator1 first1, InputIterator1 last1, 4237a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4247a984708SDavid Chisnall 4257a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4267a984708SDavid Chisnall OutputIterator 4277a984708SDavid Chisnall set_difference(InputIterator1 first1, InputIterator1 last1, 4287a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4297a984708SDavid Chisnall 4307a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator> 4317a984708SDavid Chisnall OutputIterator 4327a984708SDavid Chisnall set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 4337a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result); 4347a984708SDavid Chisnall 4357a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 4367a984708SDavid Chisnall OutputIterator 4377a984708SDavid Chisnall set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 4387a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 4397a984708SDavid Chisnall 4407a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4417a984708SDavid Chisnall void 4427a984708SDavid Chisnall push_heap(RandomAccessIterator first, RandomAccessIterator last); 4437a984708SDavid Chisnall 4447a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4457a984708SDavid Chisnall void 4467a984708SDavid Chisnall push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 4477a984708SDavid Chisnall 4487a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4497a984708SDavid Chisnall void 4507a984708SDavid Chisnall pop_heap(RandomAccessIterator first, RandomAccessIterator last); 4517a984708SDavid Chisnall 4527a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4537a984708SDavid Chisnall void 4547a984708SDavid Chisnall pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 4557a984708SDavid Chisnall 4567a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4577a984708SDavid Chisnall void 4587a984708SDavid Chisnall make_heap(RandomAccessIterator first, RandomAccessIterator last); 4597a984708SDavid Chisnall 4607a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4617a984708SDavid Chisnall void 4627a984708SDavid Chisnall make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 4637a984708SDavid Chisnall 4647a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4657a984708SDavid Chisnall void 4667a984708SDavid Chisnall sort_heap(RandomAccessIterator first, RandomAccessIterator last); 4677a984708SDavid Chisnall 4687a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4697a984708SDavid Chisnall void 4707a984708SDavid Chisnall sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 4717a984708SDavid Chisnall 4727a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4737a984708SDavid Chisnall bool 4747a984708SDavid Chisnall is_heap(RandomAccessIterator first, RandomAccessiterator last); 4757a984708SDavid Chisnall 4767a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4777a984708SDavid Chisnall bool 4787a984708SDavid Chisnall is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 4797a984708SDavid Chisnall 4807a984708SDavid Chisnalltemplate <class RandomAccessIterator> 4817a984708SDavid Chisnall RandomAccessIterator 4827a984708SDavid Chisnall is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 4837a984708SDavid Chisnall 4847a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare> 4857a984708SDavid Chisnall RandomAccessIterator 4867a984708SDavid Chisnall is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 4877a984708SDavid Chisnall 4887a984708SDavid Chisnalltemplate <class ForwardIterator> 4897a984708SDavid Chisnall ForwardIterator 4907a984708SDavid Chisnall min_element(ForwardIterator first, ForwardIterator last); 4917a984708SDavid Chisnall 4927a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 4937a984708SDavid Chisnall ForwardIterator 4947a984708SDavid Chisnall min_element(ForwardIterator first, ForwardIterator last, Compare comp); 4957a984708SDavid Chisnall 4967a984708SDavid Chisnalltemplate <class T> 4977a984708SDavid Chisnall const T& 4987a984708SDavid Chisnall min(const T& a, const T& b); 4997a984708SDavid Chisnall 5007a984708SDavid Chisnalltemplate <class T, class Compare> 5017a984708SDavid Chisnall const T& 5027a984708SDavid Chisnall min(const T& a, const T& b, Compare comp); 5037a984708SDavid Chisnall 5047a984708SDavid Chisnalltemplate<class T> 5057a984708SDavid Chisnall T 5067a984708SDavid Chisnall min(initializer_list<T> t); 5077a984708SDavid Chisnall 5087a984708SDavid Chisnalltemplate<class T, class Compare> 5097a984708SDavid Chisnall T 5107a984708SDavid Chisnall min(initializer_list<T> t, Compare comp); 5117a984708SDavid Chisnall 5127a984708SDavid Chisnalltemplate <class ForwardIterator> 5137a984708SDavid Chisnall ForwardIterator 5147a984708SDavid Chisnall max_element(ForwardIterator first, ForwardIterator last); 5157a984708SDavid Chisnall 5167a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare> 5177a984708SDavid Chisnall ForwardIterator 5187a984708SDavid Chisnall max_element(ForwardIterator first, ForwardIterator last, Compare comp); 5197a984708SDavid Chisnall 5207a984708SDavid Chisnalltemplate <class T> 5217a984708SDavid Chisnall const T& 5227a984708SDavid Chisnall max(const T& a, const T& b); 5237a984708SDavid Chisnall 5247a984708SDavid Chisnalltemplate <class T, class Compare> 5257a984708SDavid Chisnall const T& 5267a984708SDavid Chisnall max(const T& a, const T& b, Compare comp); 5277a984708SDavid Chisnall 5287a984708SDavid Chisnalltemplate<class T> 5297a984708SDavid Chisnall T 5307a984708SDavid Chisnall max(initializer_list<T> t); 5317a984708SDavid Chisnall 5327a984708SDavid Chisnalltemplate<class T, class Compare> 5337a984708SDavid Chisnall T 5347a984708SDavid Chisnall max(initializer_list<T> t, Compare comp); 5357a984708SDavid Chisnall 5367a984708SDavid Chisnalltemplate<class ForwardIterator> 5377a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 5387a984708SDavid Chisnall minmax_element(ForwardIterator first, ForwardIterator last); 5397a984708SDavid Chisnall 5407a984708SDavid Chisnalltemplate<class ForwardIterator, class Compare> 5417a984708SDavid Chisnall pair<ForwardIterator, ForwardIterator> 5427a984708SDavid Chisnall minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); 5437a984708SDavid Chisnall 5447a984708SDavid Chisnalltemplate<class T> 5457a984708SDavid Chisnall pair<const T&, const T&> 5467a984708SDavid Chisnall minmax(const T& a, const T& b); 5477a984708SDavid Chisnall 5487a984708SDavid Chisnalltemplate<class T, class Compare> 5497a984708SDavid Chisnall pair<const T&, const T&> 5507a984708SDavid Chisnall minmax(const T& a, const T& b, Compare comp); 5517a984708SDavid Chisnall 5527a984708SDavid Chisnalltemplate<class T> 5537a984708SDavid Chisnall pair<T, T> 5547a984708SDavid Chisnall minmax(initializer_list<T> t); 5557a984708SDavid Chisnall 5567a984708SDavid Chisnalltemplate<class T, class Compare> 5577a984708SDavid Chisnall pair<T, T> 5587a984708SDavid Chisnall minmax(initializer_list<T> t, Compare comp); 5597a984708SDavid Chisnall 5607a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2> 5617a984708SDavid Chisnall bool 5627a984708SDavid Chisnall lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 5637a984708SDavid Chisnall 5647a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class Compare> 5657a984708SDavid Chisnall bool 5667a984708SDavid Chisnall lexicographical_compare(InputIterator1 first1, InputIterator1 last1, 5677a984708SDavid Chisnall InputIterator2 first2, InputIterator2 last2, Compare comp); 5687a984708SDavid Chisnall 5697a984708SDavid Chisnalltemplate <class BidirectionalIterator> 5707a984708SDavid Chisnall bool 5717a984708SDavid Chisnall next_permutation(BidirectionalIterator first, BidirectionalIterator last); 5727a984708SDavid Chisnall 5737a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare> 5747a984708SDavid Chisnall bool 5757a984708SDavid Chisnall next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 5767a984708SDavid Chisnall 5777a984708SDavid Chisnalltemplate <class BidirectionalIterator> 5787a984708SDavid Chisnall bool 5797a984708SDavid Chisnall prev_permutation(BidirectionalIterator first, BidirectionalIterator last); 5807a984708SDavid Chisnall 5817a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare> 5827a984708SDavid Chisnall bool 5837a984708SDavid Chisnall prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 5847a984708SDavid Chisnall 5857a984708SDavid Chisnall} // std 5867a984708SDavid Chisnall 5877a984708SDavid Chisnall*/ 5887a984708SDavid Chisnall 5897a984708SDavid Chisnall#include <__config> 5907a984708SDavid Chisnall#include <initializer_list> 5917a984708SDavid Chisnall#include <type_traits> 5927a984708SDavid Chisnall#include <cstring> 5937a984708SDavid Chisnall#include <utility> 5947a984708SDavid Chisnall#include <memory> 5957a984708SDavid Chisnall#include <iterator> 596936e9439SDimitry Andric#include <cstddef> 5977a984708SDavid Chisnall 59894e3ee44SDavid Chisnall#include <__undef_min_max> 59994e3ee44SDavid Chisnall 6007a984708SDavid Chisnall#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 6017a984708SDavid Chisnall#pragma GCC system_header 6027a984708SDavid Chisnall#endif 6037a984708SDavid Chisnall 6047a984708SDavid Chisnall_LIBCPP_BEGIN_NAMESPACE_STD 6057a984708SDavid Chisnall 6067a984708SDavid Chisnalltemplate <class _T1, class _T2 = _T1> 6077a984708SDavid Chisnallstruct __equal_to 6087a984708SDavid Chisnall{ 6097a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6107a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;} 6117a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;} 6127a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;} 6137a984708SDavid Chisnall}; 6147a984708SDavid Chisnall 6157a984708SDavid Chisnalltemplate <class _T1> 6167a984708SDavid Chisnallstruct __equal_to<_T1, _T1> 6177a984708SDavid Chisnall{ 6187a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6197a984708SDavid Chisnall}; 6207a984708SDavid Chisnall 6217a984708SDavid Chisnalltemplate <class _T1> 6227a984708SDavid Chisnallstruct __equal_to<const _T1, _T1> 6237a984708SDavid Chisnall{ 6247a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6257a984708SDavid Chisnall}; 6267a984708SDavid Chisnall 6277a984708SDavid Chisnalltemplate <class _T1> 6287a984708SDavid Chisnallstruct __equal_to<_T1, const _T1> 6297a984708SDavid Chisnall{ 6307a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 6317a984708SDavid Chisnall}; 6327a984708SDavid Chisnall 6337a984708SDavid Chisnalltemplate <class _T1, class _T2 = _T1> 6347a984708SDavid Chisnallstruct __less 6357a984708SDavid Chisnall{ 6367a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 6377a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;} 6387a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;} 6397a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;} 6407a984708SDavid Chisnall}; 6417a984708SDavid Chisnall 6427a984708SDavid Chisnalltemplate <class _T1> 6437a984708SDavid Chisnallstruct __less<_T1, _T1> 6447a984708SDavid Chisnall{ 6457a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 6467a984708SDavid Chisnall}; 6477a984708SDavid Chisnall 6487a984708SDavid Chisnalltemplate <class _T1> 6497a984708SDavid Chisnallstruct __less<const _T1, _T1> 6507a984708SDavid Chisnall{ 6517a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 6527a984708SDavid Chisnall}; 6537a984708SDavid Chisnall 6547a984708SDavid Chisnalltemplate <class _T1> 6557a984708SDavid Chisnallstruct __less<_T1, const _T1> 6567a984708SDavid Chisnall{ 6577a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 6587a984708SDavid Chisnall}; 6597a984708SDavid Chisnall 6607a984708SDavid Chisnalltemplate <class _Predicate> 6617a984708SDavid Chisnallclass __negate 6627a984708SDavid Chisnall{ 6637a984708SDavid Chisnallprivate: 6647a984708SDavid Chisnall _Predicate __p_; 6657a984708SDavid Chisnallpublic: 6667a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY __negate() {} 6677a984708SDavid Chisnall 6687a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY 6697a984708SDavid Chisnall explicit __negate(_Predicate __p) : __p_(__p) {} 6707a984708SDavid Chisnall 6717a984708SDavid Chisnall template <class _T1> 6727a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY 6737a984708SDavid Chisnall bool operator()(const _T1& __x) {return !__p_(__x);} 6747a984708SDavid Chisnall 6757a984708SDavid Chisnall template <class _T1, class _T2> 6767a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY 6777a984708SDavid Chisnall bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);} 6787a984708SDavid Chisnall}; 6797a984708SDavid Chisnall 6807a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 6817a984708SDavid Chisnall 6827a984708SDavid Chisnalltemplate <class _Compare> 6837a984708SDavid Chisnallstruct __debug_less 6847a984708SDavid Chisnall{ 6857a984708SDavid Chisnall _Compare __comp_; 6867a984708SDavid Chisnall __debug_less(_Compare& __c) : __comp_(__c) {} 6877a984708SDavid Chisnall template <class _Tp, class _Up> 6887a984708SDavid Chisnall bool operator()(const _Tp& __x, const _Up& __y) 6897a984708SDavid Chisnall { 6907a984708SDavid Chisnall bool __r = __comp_(__x, __y); 6917a984708SDavid Chisnall if (__r) 6927a984708SDavid Chisnall _LIBCPP_ASSERT(!__comp_(__y, __x), "Comparator does not induce a strict weak ordering"); 6937a984708SDavid Chisnall return __r; 6947a984708SDavid Chisnall } 6957a984708SDavid Chisnall}; 6967a984708SDavid Chisnall 6977a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 6987a984708SDavid Chisnall 6997a984708SDavid Chisnall// Precondition: __x != 0 70094e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 70194e3ee44SDavid Chisnallunsigned 70294e3ee44SDavid Chisnall__ctz(unsigned __x) 70394e3ee44SDavid Chisnall{ 70494e3ee44SDavid Chisnall return static_cast<unsigned>(__builtin_ctz(__x)); 70594e3ee44SDavid Chisnall} 70694e3ee44SDavid Chisnall 70794e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 70894e3ee44SDavid Chisnallunsigned long 70994e3ee44SDavid Chisnall__ctz(unsigned long __x) 71094e3ee44SDavid Chisnall{ 71194e3ee44SDavid Chisnall return static_cast<unsigned long>(__builtin_ctzl(__x)); 71294e3ee44SDavid Chisnall} 71394e3ee44SDavid Chisnall 71494e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 71594e3ee44SDavid Chisnallunsigned long long 71694e3ee44SDavid Chisnall__ctz(unsigned long long __x) 71794e3ee44SDavid Chisnall{ 71894e3ee44SDavid Chisnall return static_cast<unsigned long long>(__builtin_ctzll(__x)); 71994e3ee44SDavid Chisnall} 7207a984708SDavid Chisnall 7217a984708SDavid Chisnall// Precondition: __x != 0 72294e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 72394e3ee44SDavid Chisnallunsigned 72494e3ee44SDavid Chisnall__clz(unsigned __x) 72594e3ee44SDavid Chisnall{ 72694e3ee44SDavid Chisnall return static_cast<unsigned>(__builtin_clz(__x)); 72794e3ee44SDavid Chisnall} 72894e3ee44SDavid Chisnall 72994e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 73094e3ee44SDavid Chisnallunsigned long 73194e3ee44SDavid Chisnall__clz(unsigned long __x) 73294e3ee44SDavid Chisnall{ 73394e3ee44SDavid Chisnall return static_cast<unsigned long>(__builtin_clzl (__x)); 73494e3ee44SDavid Chisnall} 73594e3ee44SDavid Chisnall 73694e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 73794e3ee44SDavid Chisnallunsigned long long 73894e3ee44SDavid Chisnall__clz(unsigned long long __x) 73994e3ee44SDavid Chisnall{ 74094e3ee44SDavid Chisnall return static_cast<unsigned long long>(__builtin_clzll(__x)); 74194e3ee44SDavid Chisnall} 7427a984708SDavid Chisnall 7437a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned __x) {return __builtin_popcount (__x);} 7447a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long __x) {return __builtin_popcountl (__x);} 7457a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long long __x) {return __builtin_popcountll(__x);} 7467a984708SDavid Chisnall 7477a984708SDavid Chisnall// all_of 7487a984708SDavid Chisnall 7497a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 7507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 7517a984708SDavid Chisnallbool 7527a984708SDavid Chisnallall_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 7537a984708SDavid Chisnall{ 7547a984708SDavid Chisnall for (; __first != __last; ++__first) 7557a984708SDavid Chisnall if (!__pred(*__first)) 7567a984708SDavid Chisnall return false; 7577a984708SDavid Chisnall return true; 7587a984708SDavid Chisnall} 7597a984708SDavid Chisnall 7607a984708SDavid Chisnall// any_of 7617a984708SDavid Chisnall 7627a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 7637a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 7647a984708SDavid Chisnallbool 7657a984708SDavid Chisnallany_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 7667a984708SDavid Chisnall{ 7677a984708SDavid Chisnall for (; __first != __last; ++__first) 7687a984708SDavid Chisnall if (__pred(*__first)) 7697a984708SDavid Chisnall return true; 7707a984708SDavid Chisnall return false; 7717a984708SDavid Chisnall} 7727a984708SDavid Chisnall 7737a984708SDavid Chisnall// none_of 7747a984708SDavid Chisnall 7757a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 7767a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 7777a984708SDavid Chisnallbool 7787a984708SDavid Chisnallnone_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 7797a984708SDavid Chisnall{ 7807a984708SDavid Chisnall for (; __first != __last; ++__first) 7817a984708SDavid Chisnall if (__pred(*__first)) 7827a984708SDavid Chisnall return false; 7837a984708SDavid Chisnall return true; 7847a984708SDavid Chisnall} 7857a984708SDavid Chisnall 7867a984708SDavid Chisnall// for_each 7877a984708SDavid Chisnall 7887a984708SDavid Chisnalltemplate <class _InputIterator, class _Function> 7897a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 7907a984708SDavid Chisnall_Function 7917a984708SDavid Chisnallfor_each(_InputIterator __first, _InputIterator __last, _Function __f) 7927a984708SDavid Chisnall{ 7937a984708SDavid Chisnall for (; __first != __last; ++__first) 7947a984708SDavid Chisnall __f(*__first); 7957a984708SDavid Chisnall return _VSTD::move(__f); 7967a984708SDavid Chisnall} 7977a984708SDavid Chisnall 7987a984708SDavid Chisnall// find 7997a984708SDavid Chisnall 8007a984708SDavid Chisnalltemplate <class _InputIterator, class _Tp> 8017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8027a984708SDavid Chisnall_InputIterator 8037a984708SDavid Chisnallfind(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 8047a984708SDavid Chisnall{ 8057a984708SDavid Chisnall for (; __first != __last; ++__first) 8067a984708SDavid Chisnall if (*__first == __value_) 8077a984708SDavid Chisnall break; 8087a984708SDavid Chisnall return __first; 8097a984708SDavid Chisnall} 8107a984708SDavid Chisnall 8117a984708SDavid Chisnall// find_if 8127a984708SDavid Chisnall 8137a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 8147a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8157a984708SDavid Chisnall_InputIterator 8167a984708SDavid Chisnallfind_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 8177a984708SDavid Chisnall{ 8187a984708SDavid Chisnall for (; __first != __last; ++__first) 8197a984708SDavid Chisnall if (__pred(*__first)) 8207a984708SDavid Chisnall break; 8217a984708SDavid Chisnall return __first; 8227a984708SDavid Chisnall} 8237a984708SDavid Chisnall 8247a984708SDavid Chisnall// find_if_not 8257a984708SDavid Chisnall 8267a984708SDavid Chisnalltemplate<class _InputIterator, class _Predicate> 8277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 8287a984708SDavid Chisnall_InputIterator 8297a984708SDavid Chisnallfind_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) 8307a984708SDavid Chisnall{ 8317a984708SDavid Chisnall for (; __first != __last; ++__first) 8327a984708SDavid Chisnall if (!__pred(*__first)) 8337a984708SDavid Chisnall break; 8347a984708SDavid Chisnall return __first; 8357a984708SDavid Chisnall} 8367a984708SDavid Chisnall 8377a984708SDavid Chisnall// find_end 8387a984708SDavid Chisnall 8397a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 8407a984708SDavid Chisnall_ForwardIterator1 8417a984708SDavid Chisnall__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 8427a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 8437a984708SDavid Chisnall forward_iterator_tag, forward_iterator_tag) 8447a984708SDavid Chisnall{ 8457a984708SDavid Chisnall // modeled after search algorithm 8467a984708SDavid Chisnall _ForwardIterator1 __r = __last1; // __last1 is the "default" answer 8477a984708SDavid Chisnall if (__first2 == __last2) 8487a984708SDavid Chisnall return __r; 8497a984708SDavid Chisnall while (true) 8507a984708SDavid Chisnall { 8517a984708SDavid Chisnall while (true) 8527a984708SDavid Chisnall { 8537a984708SDavid Chisnall if (__first1 == __last1) // if source exhausted return last correct answer 8547a984708SDavid Chisnall return __r; // (or __last1 if never found) 8557a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 8567a984708SDavid Chisnall break; 8577a984708SDavid Chisnall ++__first1; 8587a984708SDavid Chisnall } 8597a984708SDavid Chisnall // *__first1 matches *__first2, now match elements after here 8607a984708SDavid Chisnall _ForwardIterator1 __m1 = __first1; 8617a984708SDavid Chisnall _ForwardIterator2 __m2 = __first2; 8627a984708SDavid Chisnall while (true) 8637a984708SDavid Chisnall { 8647a984708SDavid Chisnall if (++__m2 == __last2) 8657a984708SDavid Chisnall { // Pattern exhaused, record answer and search for another one 8667a984708SDavid Chisnall __r = __first1; 8677a984708SDavid Chisnall ++__first1; 8687a984708SDavid Chisnall break; 8697a984708SDavid Chisnall } 8707a984708SDavid Chisnall if (++__m1 == __last1) // Source exhausted, return last answer 8717a984708SDavid Chisnall return __r; 8727a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) // mismatch, restart with a new __first 8737a984708SDavid Chisnall { 8747a984708SDavid Chisnall ++__first1; 8757a984708SDavid Chisnall break; 8767a984708SDavid Chisnall } // else there is a match, check next elements 8777a984708SDavid Chisnall } 8787a984708SDavid Chisnall } 8797a984708SDavid Chisnall} 8807a984708SDavid Chisnall 8817a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2> 8827a984708SDavid Chisnall_BidirectionalIterator1 8837a984708SDavid Chisnall__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, 8847a984708SDavid Chisnall _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred, 8857a984708SDavid Chisnall bidirectional_iterator_tag, bidirectional_iterator_tag) 8867a984708SDavid Chisnall{ 8877a984708SDavid Chisnall // modeled after search algorithm (in reverse) 8887a984708SDavid Chisnall if (__first2 == __last2) 8897a984708SDavid Chisnall return __last1; // Everything matches an empty sequence 8907a984708SDavid Chisnall _BidirectionalIterator1 __l1 = __last1; 8917a984708SDavid Chisnall _BidirectionalIterator2 __l2 = __last2; 8927a984708SDavid Chisnall --__l2; 8937a984708SDavid Chisnall while (true) 8947a984708SDavid Chisnall { 8957a984708SDavid Chisnall // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks 8967a984708SDavid Chisnall while (true) 8977a984708SDavid Chisnall { 8987a984708SDavid Chisnall if (__first1 == __l1) // return __last1 if no element matches *__first2 8997a984708SDavid Chisnall return __last1; 9007a984708SDavid Chisnall if (__pred(*--__l1, *__l2)) 9017a984708SDavid Chisnall break; 9027a984708SDavid Chisnall } 9037a984708SDavid Chisnall // *__l1 matches *__l2, now match elements before here 9047a984708SDavid Chisnall _BidirectionalIterator1 __m1 = __l1; 9057a984708SDavid Chisnall _BidirectionalIterator2 __m2 = __l2; 9067a984708SDavid Chisnall while (true) 9077a984708SDavid Chisnall { 9087a984708SDavid Chisnall if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern) 9097a984708SDavid Chisnall return __m1; 9107a984708SDavid Chisnall if (__m1 == __first1) // Otherwise if source exhaused, pattern not found 9117a984708SDavid Chisnall return __last1; 9127a984708SDavid Chisnall if (!__pred(*--__m1, *--__m2)) // if there is a mismatch, restart with a new __l1 9137a984708SDavid Chisnall { 9147a984708SDavid Chisnall break; 9157a984708SDavid Chisnall } // else there is a match, check next elements 9167a984708SDavid Chisnall } 9177a984708SDavid Chisnall } 9187a984708SDavid Chisnall} 9197a984708SDavid Chisnall 9207a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 9217a984708SDavid Chisnall_RandomAccessIterator1 9227a984708SDavid Chisnall__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 9237a984708SDavid Chisnall _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 9247a984708SDavid Chisnall random_access_iterator_tag, random_access_iterator_tag) 9257a984708SDavid Chisnall{ 9267a984708SDavid Chisnall // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 9277a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2; 9287a984708SDavid Chisnall if (__len2 == 0) 9297a984708SDavid Chisnall return __last1; 9307a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1; 9317a984708SDavid Chisnall if (__len1 < __len2) 9327a984708SDavid Chisnall return __last1; 9337a984708SDavid Chisnall const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here 9347a984708SDavid Chisnall _RandomAccessIterator1 __l1 = __last1; 9357a984708SDavid Chisnall _RandomAccessIterator2 __l2 = __last2; 9367a984708SDavid Chisnall --__l2; 9377a984708SDavid Chisnall while (true) 9387a984708SDavid Chisnall { 9397a984708SDavid Chisnall while (true) 9407a984708SDavid Chisnall { 9417a984708SDavid Chisnall if (__s == __l1) 9427a984708SDavid Chisnall return __last1; 9437a984708SDavid Chisnall if (__pred(*--__l1, *__l2)) 9447a984708SDavid Chisnall break; 9457a984708SDavid Chisnall } 9467a984708SDavid Chisnall _RandomAccessIterator1 __m1 = __l1; 9477a984708SDavid Chisnall _RandomAccessIterator2 __m2 = __l2; 9487a984708SDavid Chisnall while (true) 9497a984708SDavid Chisnall { 9507a984708SDavid Chisnall if (__m2 == __first2) 9517a984708SDavid Chisnall return __m1; 9527a984708SDavid Chisnall // no need to check range on __m1 because __s guarantees we have enough source 9537a984708SDavid Chisnall if (!__pred(*--__m1, *--__m2)) 9547a984708SDavid Chisnall { 9557a984708SDavid Chisnall break; 9567a984708SDavid Chisnall } 9577a984708SDavid Chisnall } 9587a984708SDavid Chisnall } 9597a984708SDavid Chisnall} 9607a984708SDavid Chisnall 9617a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 9627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 9637a984708SDavid Chisnall_ForwardIterator1 9647a984708SDavid Chisnallfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 9657a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 9667a984708SDavid Chisnall{ 9677a984708SDavid Chisnall return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type> 9687a984708SDavid Chisnall (__first1, __last1, __first2, __last2, __pred, 9697a984708SDavid Chisnall typename iterator_traits<_ForwardIterator1>::iterator_category(), 9707a984708SDavid Chisnall typename iterator_traits<_ForwardIterator2>::iterator_category()); 9717a984708SDavid Chisnall} 9727a984708SDavid Chisnall 9737a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2> 9747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 9757a984708SDavid Chisnall_ForwardIterator1 9767a984708SDavid Chisnallfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 9777a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 9787a984708SDavid Chisnall{ 9797a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 9807a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 9817a984708SDavid Chisnall return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 9827a984708SDavid Chisnall} 9837a984708SDavid Chisnall 9847a984708SDavid Chisnall// find_first_of 9857a984708SDavid Chisnall 9867a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 9877a984708SDavid Chisnall_ForwardIterator1 9887a984708SDavid Chisnallfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 9897a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 9907a984708SDavid Chisnall{ 9917a984708SDavid Chisnall for (; __first1 != __last1; ++__first1) 9927a984708SDavid Chisnall for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 9937a984708SDavid Chisnall if (__pred(*__first1, *__j)) 9947a984708SDavid Chisnall return __first1; 9957a984708SDavid Chisnall return __last1; 9967a984708SDavid Chisnall} 9977a984708SDavid Chisnall 9987a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2> 9997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10007a984708SDavid Chisnall_ForwardIterator1 10017a984708SDavid Chisnallfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 10027a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 10037a984708SDavid Chisnall{ 10047a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 10057a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 10067a984708SDavid Chisnall return _VSTD::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 10077a984708SDavid Chisnall} 10087a984708SDavid Chisnall 10097a984708SDavid Chisnall// adjacent_find 10107a984708SDavid Chisnall 10117a984708SDavid Chisnalltemplate <class _ForwardIterator, class _BinaryPredicate> 10127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10137a984708SDavid Chisnall_ForwardIterator 10147a984708SDavid Chisnalladjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 10157a984708SDavid Chisnall{ 10167a984708SDavid Chisnall if (__first != __last) 10177a984708SDavid Chisnall { 10187a984708SDavid Chisnall _ForwardIterator __i = __first; 10197a984708SDavid Chisnall while (++__i != __last) 10207a984708SDavid Chisnall { 10217a984708SDavid Chisnall if (__pred(*__first, *__i)) 10227a984708SDavid Chisnall return __first; 10237a984708SDavid Chisnall __first = __i; 10247a984708SDavid Chisnall } 10257a984708SDavid Chisnall } 10267a984708SDavid Chisnall return __last; 10277a984708SDavid Chisnall} 10287a984708SDavid Chisnall 10297a984708SDavid Chisnalltemplate <class _ForwardIterator> 10307a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10317a984708SDavid Chisnall_ForwardIterator 10327a984708SDavid Chisnalladjacent_find(_ForwardIterator __first, _ForwardIterator __last) 10337a984708SDavid Chisnall{ 10347a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type __v; 10357a984708SDavid Chisnall return _VSTD::adjacent_find(__first, __last, __equal_to<__v>()); 10367a984708SDavid Chisnall} 10377a984708SDavid Chisnall 10387a984708SDavid Chisnall// count 10397a984708SDavid Chisnall 10407a984708SDavid Chisnalltemplate <class _InputIterator, class _Tp> 10417a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10427a984708SDavid Chisnalltypename iterator_traits<_InputIterator>::difference_type 10437a984708SDavid Chisnallcount(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 10447a984708SDavid Chisnall{ 10457a984708SDavid Chisnall typename iterator_traits<_InputIterator>::difference_type __r(0); 10467a984708SDavid Chisnall for (; __first != __last; ++__first) 10477a984708SDavid Chisnall if (*__first == __value_) 10487a984708SDavid Chisnall ++__r; 10497a984708SDavid Chisnall return __r; 10507a984708SDavid Chisnall} 10517a984708SDavid Chisnall 10527a984708SDavid Chisnall// count_if 10537a984708SDavid Chisnall 10547a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 10557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10567a984708SDavid Chisnalltypename iterator_traits<_InputIterator>::difference_type 10577a984708SDavid Chisnallcount_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 10587a984708SDavid Chisnall{ 10597a984708SDavid Chisnall typename iterator_traits<_InputIterator>::difference_type __r(0); 10607a984708SDavid Chisnall for (; __first != __last; ++__first) 10617a984708SDavid Chisnall if (__pred(*__first)) 10627a984708SDavid Chisnall ++__r; 10637a984708SDavid Chisnall return __r; 10647a984708SDavid Chisnall} 10657a984708SDavid Chisnall 10667a984708SDavid Chisnall// mismatch 10677a984708SDavid Chisnall 10687a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 10697a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10707a984708SDavid Chisnallpair<_InputIterator1, _InputIterator2> 10717a984708SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 10727a984708SDavid Chisnall _InputIterator2 __first2, _BinaryPredicate __pred) 10737a984708SDavid Chisnall{ 10747a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__first2) 10757a984708SDavid Chisnall if (!__pred(*__first1, *__first2)) 10767a984708SDavid Chisnall break; 10777a984708SDavid Chisnall return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 10787a984708SDavid Chisnall} 10797a984708SDavid Chisnall 10807a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 10817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10827a984708SDavid Chisnallpair<_InputIterator1, _InputIterator2> 10837a984708SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 10847a984708SDavid Chisnall{ 10857a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 10867a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 10877a984708SDavid Chisnall return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 10887a984708SDavid Chisnall} 10897a984708SDavid Chisnall 10907a984708SDavid Chisnall// equal 10917a984708SDavid Chisnall 10927a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 10937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 10947a984708SDavid Chisnallbool 10957a984708SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) 10967a984708SDavid Chisnall{ 10977a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__first2) 10987a984708SDavid Chisnall if (!__pred(*__first1, *__first2)) 10997a984708SDavid Chisnall return false; 11007a984708SDavid Chisnall return true; 11017a984708SDavid Chisnall} 11027a984708SDavid Chisnall 11037a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 11047a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11057a984708SDavid Chisnallbool 11067a984708SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 11077a984708SDavid Chisnall{ 11087a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 11097a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 11107a984708SDavid Chisnall return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 11117a984708SDavid Chisnall} 11127a984708SDavid Chisnall 11137a984708SDavid Chisnall// is_permutation 11147a984708SDavid Chisnall 11157a984708SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 11167a984708SDavid Chisnallbool 11177a984708SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 11187a984708SDavid Chisnall _ForwardIterator2 __first2, _BinaryPredicate __pred) 11197a984708SDavid Chisnall{ 11207a984708SDavid Chisnall // shorten sequences as much as possible by lopping of any equal parts 11217a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__first2) 11227a984708SDavid Chisnall if (!__pred(*__first1, *__first2)) 11237a984708SDavid Chisnall goto __not_done; 11247a984708SDavid Chisnall return true; 11257a984708SDavid Chisnall__not_done: 11267a984708SDavid Chisnall // __first1 != __last1 && *__first1 != *__first2 11277a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 11287a984708SDavid Chisnall _D1 __l1 = _VSTD::distance(__first1, __last1); 11297a984708SDavid Chisnall if (__l1 == _D1(1)) 11307a984708SDavid Chisnall return false; 11317a984708SDavid Chisnall _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1); 11327a984708SDavid Chisnall // For each element in [f1, l1) see if there are the same number of 11337a984708SDavid Chisnall // equal elements in [f2, l2) 11347a984708SDavid Chisnall for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 11357a984708SDavid Chisnall { 11367a984708SDavid Chisnall // Have we already counted the number of *__i in [f1, l1)? 11377a984708SDavid Chisnall for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 11387a984708SDavid Chisnall if (__pred(*__j, *__i)) 11397a984708SDavid Chisnall goto __next_iter; 11407a984708SDavid Chisnall { 11417a984708SDavid Chisnall // Count number of *__i in [f2, l2) 11427a984708SDavid Chisnall _D1 __c2 = 0; 11437a984708SDavid Chisnall for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 11447a984708SDavid Chisnall if (__pred(*__i, *__j)) 11457a984708SDavid Chisnall ++__c2; 11467a984708SDavid Chisnall if (__c2 == 0) 11477a984708SDavid Chisnall return false; 11487a984708SDavid Chisnall // Count number of *__i in [__i, l1) (we can start with 1) 11497a984708SDavid Chisnall _D1 __c1 = 1; 11507a984708SDavid Chisnall for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 11517a984708SDavid Chisnall if (__pred(*__i, *__j)) 11527a984708SDavid Chisnall ++__c1; 11537a984708SDavid Chisnall if (__c1 != __c2) 11547a984708SDavid Chisnall return false; 11557a984708SDavid Chisnall } 11567a984708SDavid Chisnall__next_iter:; 11577a984708SDavid Chisnall } 11587a984708SDavid Chisnall return true; 11597a984708SDavid Chisnall} 11607a984708SDavid Chisnall 11617a984708SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2> 11627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 11637a984708SDavid Chisnallbool 11647a984708SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 11657a984708SDavid Chisnall _ForwardIterator2 __first2) 11667a984708SDavid Chisnall{ 11677a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 11687a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 11697a984708SDavid Chisnall return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 11707a984708SDavid Chisnall} 11717a984708SDavid Chisnall 11727a984708SDavid Chisnall// search 11737a984708SDavid Chisnall 11747a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 11757a984708SDavid Chisnall_ForwardIterator1 11767a984708SDavid Chisnall__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 11777a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 11787a984708SDavid Chisnall forward_iterator_tag, forward_iterator_tag) 11797a984708SDavid Chisnall{ 11807a984708SDavid Chisnall if (__first2 == __last2) 11817a984708SDavid Chisnall return __first1; // Everything matches an empty sequence 11827a984708SDavid Chisnall while (true) 11837a984708SDavid Chisnall { 11847a984708SDavid Chisnall // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks 11857a984708SDavid Chisnall while (true) 11867a984708SDavid Chisnall { 11877a984708SDavid Chisnall if (__first1 == __last1) // return __last1 if no element matches *__first2 11887a984708SDavid Chisnall return __last1; 11897a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 11907a984708SDavid Chisnall break; 11917a984708SDavid Chisnall ++__first1; 11927a984708SDavid Chisnall } 11937a984708SDavid Chisnall // *__first1 matches *__first2, now match elements after here 11947a984708SDavid Chisnall _ForwardIterator1 __m1 = __first1; 11957a984708SDavid Chisnall _ForwardIterator2 __m2 = __first2; 11967a984708SDavid Chisnall while (true) 11977a984708SDavid Chisnall { 11987a984708SDavid Chisnall if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern) 11997a984708SDavid Chisnall return __first1; 12007a984708SDavid Chisnall if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found 12017a984708SDavid Chisnall return __last1; 12027a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1 12037a984708SDavid Chisnall { 12047a984708SDavid Chisnall ++__first1; 12057a984708SDavid Chisnall break; 12067a984708SDavid Chisnall } // else there is a match, check next elements 12077a984708SDavid Chisnall } 12087a984708SDavid Chisnall } 12097a984708SDavid Chisnall} 12107a984708SDavid Chisnall 12117a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 12127a984708SDavid Chisnall_RandomAccessIterator1 12137a984708SDavid Chisnall__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 12147a984708SDavid Chisnall _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 12157a984708SDavid Chisnall random_access_iterator_tag, random_access_iterator_tag) 12167a984708SDavid Chisnall{ 12177a984708SDavid Chisnall typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _D1; 12187a984708SDavid Chisnall typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _D2; 12197a984708SDavid Chisnall // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 12207a984708SDavid Chisnall _D2 __len2 = __last2 - __first2; 12217a984708SDavid Chisnall if (__len2 == 0) 12227a984708SDavid Chisnall return __first1; 12237a984708SDavid Chisnall _D1 __len1 = __last1 - __first1; 12247a984708SDavid Chisnall if (__len1 < __len2) 12257a984708SDavid Chisnall return __last1; 12267a984708SDavid Chisnall const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here 12277a984708SDavid Chisnall while (true) 12287a984708SDavid Chisnall { 12297a984708SDavid Chisnall#if !_LIBCPP_UNROLL_LOOPS 12307a984708SDavid Chisnall while (true) 12317a984708SDavid Chisnall { 12327a984708SDavid Chisnall if (__first1 == __s) 12337a984708SDavid Chisnall return __last1; 12347a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 12357a984708SDavid Chisnall break; 12367a984708SDavid Chisnall ++__first1; 12377a984708SDavid Chisnall } 12387a984708SDavid Chisnall#else // !_LIBCPP_UNROLL_LOOPS 12397a984708SDavid Chisnall for (_D1 __loop_unroll = (__s - __first1) / 4; __loop_unroll > 0; --__loop_unroll) 12407a984708SDavid Chisnall { 12417a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 12427a984708SDavid Chisnall goto __phase2; 12437a984708SDavid Chisnall if (__pred(*++__first1, *__first2)) 12447a984708SDavid Chisnall goto __phase2; 12457a984708SDavid Chisnall if (__pred(*++__first1, *__first2)) 12467a984708SDavid Chisnall goto __phase2; 12477a984708SDavid Chisnall if (__pred(*++__first1, *__first2)) 12487a984708SDavid Chisnall goto __phase2; 12497a984708SDavid Chisnall ++__first1; 12507a984708SDavid Chisnall } 12517a984708SDavid Chisnall switch (__s - __first1) 12527a984708SDavid Chisnall { 12537a984708SDavid Chisnall case 3: 12547a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 12557a984708SDavid Chisnall break; 12567a984708SDavid Chisnall ++__first1; 12577a984708SDavid Chisnall case 2: 12587a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 12597a984708SDavid Chisnall break; 12607a984708SDavid Chisnall ++__first1; 12617a984708SDavid Chisnall case 1: 12627a984708SDavid Chisnall if (__pred(*__first1, *__first2)) 12637a984708SDavid Chisnall break; 12647a984708SDavid Chisnall case 0: 12657a984708SDavid Chisnall return __last1; 12667a984708SDavid Chisnall } 12677a984708SDavid Chisnall __phase2: 12687a984708SDavid Chisnall#endif // !_LIBCPP_UNROLL_LOOPS 12697a984708SDavid Chisnall _RandomAccessIterator1 __m1 = __first1; 12707a984708SDavid Chisnall _RandomAccessIterator2 __m2 = __first2; 12717a984708SDavid Chisnall#if !_LIBCPP_UNROLL_LOOPS 12727a984708SDavid Chisnall while (true) 12737a984708SDavid Chisnall { 12747a984708SDavid Chisnall if (++__m2 == __last2) 12757a984708SDavid Chisnall return __first1; 12767a984708SDavid Chisnall ++__m1; // no need to check range on __m1 because __s guarantees we have enough source 12777a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) 12787a984708SDavid Chisnall { 12797a984708SDavid Chisnall ++__first1; 12807a984708SDavid Chisnall break; 12817a984708SDavid Chisnall } 12827a984708SDavid Chisnall } 12837a984708SDavid Chisnall#else // !_LIBCPP_UNROLL_LOOPS 12847a984708SDavid Chisnall ++__m2; 12857a984708SDavid Chisnall ++__m1; 12867a984708SDavid Chisnall for (_D2 __loop_unroll = (__last2 - __m2) / 4; __loop_unroll > 0; --__loop_unroll) 12877a984708SDavid Chisnall { 12887a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) 12897a984708SDavid Chisnall goto __continue; 12907a984708SDavid Chisnall if (!__pred(*++__m1, *++__m2)) 12917a984708SDavid Chisnall goto __continue; 12927a984708SDavid Chisnall if (!__pred(*++__m1, *++__m2)) 12937a984708SDavid Chisnall goto __continue; 12947a984708SDavid Chisnall if (!__pred(*++__m1, *++__m2)) 12957a984708SDavid Chisnall goto __continue; 12967a984708SDavid Chisnall ++__m1; 12977a984708SDavid Chisnall ++__m2; 12987a984708SDavid Chisnall } 12997a984708SDavid Chisnall switch (__last2 - __m2) 13007a984708SDavid Chisnall { 13017a984708SDavid Chisnall case 3: 13027a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) 13037a984708SDavid Chisnall break; 13047a984708SDavid Chisnall ++__m1; 13057a984708SDavid Chisnall ++__m2; 13067a984708SDavid Chisnall case 2: 13077a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) 13087a984708SDavid Chisnall break; 13097a984708SDavid Chisnall ++__m1; 13107a984708SDavid Chisnall ++__m2; 13117a984708SDavid Chisnall case 1: 13127a984708SDavid Chisnall if (!__pred(*__m1, *__m2)) 13137a984708SDavid Chisnall break; 13147a984708SDavid Chisnall case 0: 13157a984708SDavid Chisnall return __first1; 13167a984708SDavid Chisnall } 13177a984708SDavid Chisnall __continue: 13187a984708SDavid Chisnall ++__first1; 13197a984708SDavid Chisnall#endif // !_LIBCPP_UNROLL_LOOPS 13207a984708SDavid Chisnall } 13217a984708SDavid Chisnall} 13227a984708SDavid Chisnall 13237a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 13247a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 13257a984708SDavid Chisnall_ForwardIterator1 13267a984708SDavid Chisnallsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 13277a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 13287a984708SDavid Chisnall{ 13297a984708SDavid Chisnall return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type> 13307a984708SDavid Chisnall (__first1, __last1, __first2, __last2, __pred, 13317a984708SDavid Chisnall typename std::iterator_traits<_ForwardIterator1>::iterator_category(), 13327a984708SDavid Chisnall typename std::iterator_traits<_ForwardIterator2>::iterator_category()); 13337a984708SDavid Chisnall} 13347a984708SDavid Chisnall 13357a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2> 13367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 13377a984708SDavid Chisnall_ForwardIterator1 13387a984708SDavid Chisnallsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 13397a984708SDavid Chisnall _ForwardIterator2 __first2, _ForwardIterator2 __last2) 13407a984708SDavid Chisnall{ 13417a984708SDavid Chisnall typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1; 13427a984708SDavid Chisnall typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2; 13437a984708SDavid Chisnall return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 13447a984708SDavid Chisnall} 13457a984708SDavid Chisnall 13467a984708SDavid Chisnall// search_n 13477a984708SDavid Chisnall 13487a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp> 13497a984708SDavid Chisnall_ForwardIterator 13507a984708SDavid Chisnall__search_n(_ForwardIterator __first, _ForwardIterator __last, 13517a984708SDavid Chisnall _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag) 13527a984708SDavid Chisnall{ 13537a984708SDavid Chisnall if (__count <= 0) 13547a984708SDavid Chisnall return __first; 13557a984708SDavid Chisnall while (true) 13567a984708SDavid Chisnall { 13577a984708SDavid Chisnall // Find first element in sequence that matchs __value_, with a mininum of loop checks 13587a984708SDavid Chisnall while (true) 13597a984708SDavid Chisnall { 13607a984708SDavid Chisnall if (__first == __last) // return __last if no element matches __value_ 13617a984708SDavid Chisnall return __last; 13627a984708SDavid Chisnall if (__pred(*__first, __value_)) 13637a984708SDavid Chisnall break; 13647a984708SDavid Chisnall ++__first; 13657a984708SDavid Chisnall } 13667a984708SDavid Chisnall // *__first matches __value_, now match elements after here 13677a984708SDavid Chisnall _ForwardIterator __m = __first; 13687a984708SDavid Chisnall _Size __c(0); 13697a984708SDavid Chisnall while (true) 13707a984708SDavid Chisnall { 13717a984708SDavid Chisnall if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 13727a984708SDavid Chisnall return __first; 13737a984708SDavid Chisnall if (++__m == __last) // Otherwise if source exhaused, pattern not found 13747a984708SDavid Chisnall return __last; 13757a984708SDavid Chisnall if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 13767a984708SDavid Chisnall { 13777a984708SDavid Chisnall __first = __m; 13787a984708SDavid Chisnall ++__first; 13797a984708SDavid Chisnall break; 13807a984708SDavid Chisnall } // else there is a match, check next elements 13817a984708SDavid Chisnall } 13827a984708SDavid Chisnall } 13837a984708SDavid Chisnall} 13847a984708SDavid Chisnall 13857a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp> 13867a984708SDavid Chisnall_RandomAccessIterator 13877a984708SDavid Chisnall__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last, 13887a984708SDavid Chisnall _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag) 13897a984708SDavid Chisnall{ 13907a984708SDavid Chisnall if (__count <= 0) 13917a984708SDavid Chisnall return __first; 13927a984708SDavid Chisnall _Size __len = static_cast<_Size>(__last - __first); 13937a984708SDavid Chisnall if (__len < __count) 13947a984708SDavid Chisnall return __last; 13957a984708SDavid Chisnall const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here 13967a984708SDavid Chisnall while (true) 13977a984708SDavid Chisnall { 13987a984708SDavid Chisnall // Find first element in sequence that matchs __value_, with a mininum of loop checks 13997a984708SDavid Chisnall while (true) 14007a984708SDavid Chisnall { 14017a984708SDavid Chisnall if (__first == __s) // return __last if no element matches __value_ 14027a984708SDavid Chisnall return __last; 14037a984708SDavid Chisnall if (__pred(*__first, __value_)) 14047a984708SDavid Chisnall break; 14057a984708SDavid Chisnall ++__first; 14067a984708SDavid Chisnall } 14077a984708SDavid Chisnall // *__first matches __value_, now match elements after here 14087a984708SDavid Chisnall _RandomAccessIterator __m = __first; 14097a984708SDavid Chisnall _Size __c(0); 14107a984708SDavid Chisnall while (true) 14117a984708SDavid Chisnall { 14127a984708SDavid Chisnall if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 14137a984708SDavid Chisnall return __first; 14147a984708SDavid Chisnall ++__m; // no need to check range on __m because __s guarantees we have enough source 14157a984708SDavid Chisnall if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 14167a984708SDavid Chisnall { 14177a984708SDavid Chisnall __first = __m; 14187a984708SDavid Chisnall ++__first; 14197a984708SDavid Chisnall break; 14207a984708SDavid Chisnall } // else there is a match, check next elements 14217a984708SDavid Chisnall } 14227a984708SDavid Chisnall } 14237a984708SDavid Chisnall} 14247a984708SDavid Chisnall 14257a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> 14267a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14277a984708SDavid Chisnall_ForwardIterator 14287a984708SDavid Chisnallsearch_n(_ForwardIterator __first, _ForwardIterator __last, 14297a984708SDavid Chisnall _Size __count, const _Tp& __value_, _BinaryPredicate __pred) 14307a984708SDavid Chisnall{ 14317a984708SDavid Chisnall return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type> 14327a984708SDavid Chisnall (__first, __last, __count, __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 14337a984708SDavid Chisnall} 14347a984708SDavid Chisnall 14357a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Size, class _Tp> 14367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14377a984708SDavid Chisnall_ForwardIterator 14387a984708SDavid Chisnallsearch_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) 14397a984708SDavid Chisnall{ 14407a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type __v; 14417a984708SDavid Chisnall return _VSTD::search_n(__first, __last, __count, __value_, __equal_to<__v, _Tp>()); 14427a984708SDavid Chisnall} 14437a984708SDavid Chisnall 14447a984708SDavid Chisnall// copy 14457a984708SDavid Chisnall 14467a984708SDavid Chisnalltemplate <class _Iter> 14477a984708SDavid Chisnallstruct __libcpp_is_trivial_iterator 14487a984708SDavid Chisnall{ 14497a984708SDavid Chisnall static const bool value = is_pointer<_Iter>::value; 14507a984708SDavid Chisnall}; 14517a984708SDavid Chisnall 14527a984708SDavid Chisnalltemplate <class _Iter> 14537a984708SDavid Chisnallstruct __libcpp_is_trivial_iterator<move_iterator<_Iter> > 14547a984708SDavid Chisnall{ 14557a984708SDavid Chisnall static const bool value = is_pointer<_Iter>::value; 14567a984708SDavid Chisnall}; 14577a984708SDavid Chisnall 14587a984708SDavid Chisnalltemplate <class _Iter> 14597a984708SDavid Chisnallstruct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> > 14607a984708SDavid Chisnall{ 14617a984708SDavid Chisnall static const bool value = is_pointer<_Iter>::value; 14627a984708SDavid Chisnall}; 14637a984708SDavid Chisnall 14647a984708SDavid Chisnalltemplate <class _Iter> 14657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14667a984708SDavid Chisnall_Iter 14677a984708SDavid Chisnall__unwrap_iter(_Iter __i) 14687a984708SDavid Chisnall{ 14697a984708SDavid Chisnall return __i; 14707a984708SDavid Chisnall} 14717a984708SDavid Chisnall 14727a984708SDavid Chisnalltemplate <class _Tp> 14737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14747a984708SDavid Chisnalltypename enable_if 14757a984708SDavid Chisnall< 14767a984708SDavid Chisnall is_trivially_copy_assignable<_Tp>::value, 14777a984708SDavid Chisnall _Tp* 14787a984708SDavid Chisnall>::type 14797a984708SDavid Chisnall__unwrap_iter(move_iterator<_Tp*> __i) 14807a984708SDavid Chisnall{ 14817a984708SDavid Chisnall return __i.base(); 14827a984708SDavid Chisnall} 14837a984708SDavid Chisnall 14847a984708SDavid Chisnalltemplate <class _Tp> 14857a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14867a984708SDavid Chisnalltypename enable_if 14877a984708SDavid Chisnall< 14887a984708SDavid Chisnall is_trivially_copy_assignable<_Tp>::value, 14897a984708SDavid Chisnall _Tp* 14907a984708SDavid Chisnall>::type 14917a984708SDavid Chisnall__unwrap_iter(__wrap_iter<_Tp*> __i) 14927a984708SDavid Chisnall{ 14937a984708SDavid Chisnall return __i.base(); 14947a984708SDavid Chisnall} 14957a984708SDavid Chisnall 14967a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 14977a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 14987a984708SDavid Chisnall_OutputIterator 14997a984708SDavid Chisnall__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 15007a984708SDavid Chisnall{ 15017a984708SDavid Chisnall for (; __first != __last; ++__first, ++__result) 15027a984708SDavid Chisnall *__result = *__first; 15037a984708SDavid Chisnall return __result; 15047a984708SDavid Chisnall} 15057a984708SDavid Chisnall 15067a984708SDavid Chisnalltemplate <class _Tp, class _Up> 15077a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15087a984708SDavid Chisnalltypename enable_if 15097a984708SDavid Chisnall< 15107a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 15117a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 15127a984708SDavid Chisnall _Up* 15137a984708SDavid Chisnall>::type 15147a984708SDavid Chisnall__copy(_Tp* __first, _Tp* __last, _Up* __result) 15157a984708SDavid Chisnall{ 15167a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 15177a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 15187a984708SDavid Chisnall return __result + __n; 15197a984708SDavid Chisnall} 15207a984708SDavid Chisnall 15217a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 15227a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15237a984708SDavid Chisnall_OutputIterator 15247a984708SDavid Chisnallcopy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 15257a984708SDavid Chisnall{ 15267a984708SDavid Chisnall return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 15277a984708SDavid Chisnall} 15287a984708SDavid Chisnall 15297a984708SDavid Chisnall// copy_backward 15307a984708SDavid Chisnall 1531cfdf2879SDavid Chisnalltemplate <class _BidirectionalIterator, class _OutputIterator> 15327a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15337a984708SDavid Chisnall_OutputIterator 1534cfdf2879SDavid Chisnall__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 15357a984708SDavid Chisnall{ 15367a984708SDavid Chisnall while (__first != __last) 15377a984708SDavid Chisnall *--__result = *--__last; 15387a984708SDavid Chisnall return __result; 15397a984708SDavid Chisnall} 15407a984708SDavid Chisnall 15417a984708SDavid Chisnalltemplate <class _Tp, class _Up> 15427a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15437a984708SDavid Chisnalltypename enable_if 15447a984708SDavid Chisnall< 15457a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 15467a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 15477a984708SDavid Chisnall _Up* 15487a984708SDavid Chisnall>::type 15497a984708SDavid Chisnall__copy_backward(_Tp* __first, _Tp* __last, _Up* __result) 15507a984708SDavid Chisnall{ 15517a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 15527a984708SDavid Chisnall __result -= __n; 15537a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 15547a984708SDavid Chisnall return __result; 15557a984708SDavid Chisnall} 15567a984708SDavid Chisnall 15577a984708SDavid Chisnalltemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 15587a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15597a984708SDavid Chisnall_BidirectionalIterator2 15607a984708SDavid Chisnallcopy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 15617a984708SDavid Chisnall _BidirectionalIterator2 __result) 15627a984708SDavid Chisnall{ 15637a984708SDavid Chisnall return _VSTD::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 15647a984708SDavid Chisnall} 15657a984708SDavid Chisnall 15667a984708SDavid Chisnall// copy_if 15677a984708SDavid Chisnall 15687a984708SDavid Chisnalltemplate<class _InputIterator, class _OutputIterator, class _Predicate> 15697a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15707a984708SDavid Chisnall_OutputIterator 15717a984708SDavid Chisnallcopy_if(_InputIterator __first, _InputIterator __last, 15727a984708SDavid Chisnall _OutputIterator __result, _Predicate __pred) 15737a984708SDavid Chisnall{ 15747a984708SDavid Chisnall for (; __first != __last; ++__first) 15757a984708SDavid Chisnall { 15767a984708SDavid Chisnall if (__pred(*__first)) 15777a984708SDavid Chisnall { 15787a984708SDavid Chisnall *__result = *__first; 15797a984708SDavid Chisnall ++__result; 15807a984708SDavid Chisnall } 15817a984708SDavid Chisnall } 15827a984708SDavid Chisnall return __result; 15837a984708SDavid Chisnall} 15847a984708SDavid Chisnall 15857a984708SDavid Chisnall// copy_n 15867a984708SDavid Chisnall 15877a984708SDavid Chisnalltemplate<class _InputIterator, class _Size, class _OutputIterator> 15887a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 15897a984708SDavid Chisnalltypename enable_if 15907a984708SDavid Chisnall< 15917a984708SDavid Chisnall __is_input_iterator<_InputIterator>::value && 15927a984708SDavid Chisnall !__is_random_access_iterator<_InputIterator>::value, 15937a984708SDavid Chisnall _OutputIterator 15947a984708SDavid Chisnall>::type 15957a984708SDavid Chisnallcopy_n(_InputIterator __first, _Size __n, _OutputIterator __result) 15967a984708SDavid Chisnall{ 15977a984708SDavid Chisnall if (__n > 0) 15987a984708SDavid Chisnall { 15997a984708SDavid Chisnall *__result = *__first; 16007a984708SDavid Chisnall ++__result; 16017a984708SDavid Chisnall for (--__n; __n > 0; --__n) 16027a984708SDavid Chisnall { 16037a984708SDavid Chisnall ++__first; 16047a984708SDavid Chisnall *__result = *__first; 16057a984708SDavid Chisnall ++__result; 16067a984708SDavid Chisnall } 16077a984708SDavid Chisnall } 16087a984708SDavid Chisnall return __result; 16097a984708SDavid Chisnall} 16107a984708SDavid Chisnall 16117a984708SDavid Chisnalltemplate<class _InputIterator, class _Size, class _OutputIterator> 16127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16137a984708SDavid Chisnalltypename enable_if 16147a984708SDavid Chisnall< 16157a984708SDavid Chisnall __is_random_access_iterator<_InputIterator>::value, 16167a984708SDavid Chisnall _OutputIterator 16177a984708SDavid Chisnall>::type 16187a984708SDavid Chisnallcopy_n(_InputIterator __first, _Size __n, _OutputIterator __result) 16197a984708SDavid Chisnall{ 16207a984708SDavid Chisnall return _VSTD::copy(__first, __first + __n, __result); 16217a984708SDavid Chisnall} 16227a984708SDavid Chisnall 16237a984708SDavid Chisnall// move 16247a984708SDavid Chisnall 16257a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 16267a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16277a984708SDavid Chisnall_OutputIterator 16287a984708SDavid Chisnall__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 16297a984708SDavid Chisnall{ 16307a984708SDavid Chisnall for (; __first != __last; ++__first, ++__result) 16317a984708SDavid Chisnall *__result = _VSTD::move(*__first); 16327a984708SDavid Chisnall return __result; 16337a984708SDavid Chisnall} 16347a984708SDavid Chisnall 16357a984708SDavid Chisnalltemplate <class _Tp, class _Up> 16367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16377a984708SDavid Chisnalltypename enable_if 16387a984708SDavid Chisnall< 16397a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 16407a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 16417a984708SDavid Chisnall _Up* 16427a984708SDavid Chisnall>::type 16437a984708SDavid Chisnall__move(_Tp* __first, _Tp* __last, _Up* __result) 16447a984708SDavid Chisnall{ 16457a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 16467a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 16477a984708SDavid Chisnall return __result + __n; 16487a984708SDavid Chisnall} 16497a984708SDavid Chisnall 16507a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 16517a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16527a984708SDavid Chisnall_OutputIterator 16537a984708SDavid Chisnallmove(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 16547a984708SDavid Chisnall{ 16557a984708SDavid Chisnall return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 16567a984708SDavid Chisnall} 16577a984708SDavid Chisnall 16587a984708SDavid Chisnall// move_backward 16597a984708SDavid Chisnall 16607a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 16617a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16627a984708SDavid Chisnall_OutputIterator 16637a984708SDavid Chisnall__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 16647a984708SDavid Chisnall{ 16657a984708SDavid Chisnall while (__first != __last) 16667a984708SDavid Chisnall *--__result = _VSTD::move(*--__last); 16677a984708SDavid Chisnall return __result; 16687a984708SDavid Chisnall} 16697a984708SDavid Chisnall 16707a984708SDavid Chisnalltemplate <class _Tp, class _Up> 16717a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16727a984708SDavid Chisnalltypename enable_if 16737a984708SDavid Chisnall< 16747a984708SDavid Chisnall is_same<typename remove_const<_Tp>::type, _Up>::value && 16757a984708SDavid Chisnall is_trivially_copy_assignable<_Up>::value, 16767a984708SDavid Chisnall _Up* 16777a984708SDavid Chisnall>::type 16787a984708SDavid Chisnall__move_backward(_Tp* __first, _Tp* __last, _Up* __result) 16797a984708SDavid Chisnall{ 16807a984708SDavid Chisnall const size_t __n = static_cast<size_t>(__last - __first); 16817a984708SDavid Chisnall __result -= __n; 16827a984708SDavid Chisnall _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 16837a984708SDavid Chisnall return __result; 16847a984708SDavid Chisnall} 16857a984708SDavid Chisnall 16867a984708SDavid Chisnalltemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 16877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 16887a984708SDavid Chisnall_BidirectionalIterator2 16897a984708SDavid Chisnallmove_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 16907a984708SDavid Chisnall _BidirectionalIterator2 __result) 16917a984708SDavid Chisnall{ 16927a984708SDavid Chisnall return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 16937a984708SDavid Chisnall} 16947a984708SDavid Chisnall 16957a984708SDavid Chisnall// iter_swap 16967a984708SDavid Chisnall 16977a984708SDavid Chisnall// moved to <type_traits> for better swap / noexcept support 16987a984708SDavid Chisnall 16997a984708SDavid Chisnall// transform 17007a984708SDavid Chisnall 17017a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _UnaryOperation> 17027a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17037a984708SDavid Chisnall_OutputIterator 17047a984708SDavid Chisnalltransform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) 17057a984708SDavid Chisnall{ 17067a984708SDavid Chisnall for (; __first != __last; ++__first, ++__result) 17077a984708SDavid Chisnall *__result = __op(*__first); 17087a984708SDavid Chisnall return __result; 17097a984708SDavid Chisnall} 17107a984708SDavid Chisnall 17117a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation> 17127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17137a984708SDavid Chisnall_OutputIterator 17147a984708SDavid Chisnalltransform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, 17157a984708SDavid Chisnall _OutputIterator __result, _BinaryOperation __binary_op) 17167a984708SDavid Chisnall{ 17177a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__first2, ++__result) 17187a984708SDavid Chisnall *__result = __binary_op(*__first1, *__first2); 17197a984708SDavid Chisnall return __result; 17207a984708SDavid Chisnall} 17217a984708SDavid Chisnall 17227a984708SDavid Chisnall// replace 17237a984708SDavid Chisnall 17247a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 17257a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17267a984708SDavid Chisnallvoid 17277a984708SDavid Chisnallreplace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) 17287a984708SDavid Chisnall{ 17297a984708SDavid Chisnall for (; __first != __last; ++__first) 17307a984708SDavid Chisnall if (*__first == __old_value) 17317a984708SDavid Chisnall *__first = __new_value; 17327a984708SDavid Chisnall} 17337a984708SDavid Chisnall 17347a984708SDavid Chisnall// replace_if 17357a984708SDavid Chisnall 17367a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate, class _Tp> 17377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17387a984708SDavid Chisnallvoid 17397a984708SDavid Chisnallreplace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) 17407a984708SDavid Chisnall{ 17417a984708SDavid Chisnall for (; __first != __last; ++__first) 17427a984708SDavid Chisnall if (__pred(*__first)) 17437a984708SDavid Chisnall *__first = __new_value; 17447a984708SDavid Chisnall} 17457a984708SDavid Chisnall 17467a984708SDavid Chisnall// replace_copy 17477a984708SDavid Chisnall 17487a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Tp> 17497a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17507a984708SDavid Chisnall_OutputIterator 17517a984708SDavid Chisnallreplace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 17527a984708SDavid Chisnall const _Tp& __old_value, const _Tp& __new_value) 17537a984708SDavid Chisnall{ 17547a984708SDavid Chisnall for (; __first != __last; ++__first, ++__result) 17557a984708SDavid Chisnall if (*__first == __old_value) 17567a984708SDavid Chisnall *__result = __new_value; 17577a984708SDavid Chisnall else 17587a984708SDavid Chisnall *__result = *__first; 17597a984708SDavid Chisnall return __result; 17607a984708SDavid Chisnall} 17617a984708SDavid Chisnall 17627a984708SDavid Chisnall// replace_copy_if 17637a984708SDavid Chisnall 17647a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp> 17657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17667a984708SDavid Chisnall_OutputIterator 17677a984708SDavid Chisnallreplace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 17687a984708SDavid Chisnall _Predicate __pred, const _Tp& __new_value) 17697a984708SDavid Chisnall{ 17707a984708SDavid Chisnall for (; __first != __last; ++__first, ++__result) 17717a984708SDavid Chisnall if (__pred(*__first)) 17727a984708SDavid Chisnall *__result = __new_value; 17737a984708SDavid Chisnall else 17747a984708SDavid Chisnall *__result = *__first; 17757a984708SDavid Chisnall return __result; 17767a984708SDavid Chisnall} 17777a984708SDavid Chisnall 17787a984708SDavid Chisnall// fill_n 17797a984708SDavid Chisnall 17807a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp> 17817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17827a984708SDavid Chisnall_OutputIterator 17837a984708SDavid Chisnall__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_, false_type) 17847a984708SDavid Chisnall{ 17857a984708SDavid Chisnall for (; __n > 0; ++__first, --__n) 17867a984708SDavid Chisnall *__first = __value_; 17877a984708SDavid Chisnall return __first; 17887a984708SDavid Chisnall} 17897a984708SDavid Chisnall 17907a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp> 17917a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 17927a984708SDavid Chisnall_OutputIterator 17937a984708SDavid Chisnall__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_, true_type) 17947a984708SDavid Chisnall{ 17957a984708SDavid Chisnall if (__n > 0) 17967a984708SDavid Chisnall _VSTD::memset(__first, (unsigned char)__value_, (size_t)(__n)); 17977a984708SDavid Chisnall return __first + __n; 17987a984708SDavid Chisnall} 17997a984708SDavid Chisnall 18007a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp> 18017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18027a984708SDavid Chisnall_OutputIterator 18037a984708SDavid Chisnallfill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 18047a984708SDavid Chisnall{ 18057a984708SDavid Chisnall return _VSTD::__fill_n(__first, __n, __value_, integral_constant<bool, 18067a984708SDavid Chisnall is_pointer<_OutputIterator>::value && 18077a984708SDavid Chisnall is_trivially_copy_assignable<_Tp>::value && 18087a984708SDavid Chisnall sizeof(_Tp) == 1>()); 18097a984708SDavid Chisnall} 18107a984708SDavid Chisnall 18117a984708SDavid Chisnall// fill 18127a984708SDavid Chisnall 18137a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 18147a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18157a984708SDavid Chisnallvoid 18167a984708SDavid Chisnall__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag) 18177a984708SDavid Chisnall{ 18187a984708SDavid Chisnall for (; __first != __last; ++__first) 18197a984708SDavid Chisnall *__first = __value_; 18207a984708SDavid Chisnall} 18217a984708SDavid Chisnall 18227a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Tp> 18237a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18247a984708SDavid Chisnallvoid 18257a984708SDavid Chisnall__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag) 18267a984708SDavid Chisnall{ 18277a984708SDavid Chisnall _VSTD::fill_n(__first, __last - __first, __value_); 18287a984708SDavid Chisnall} 18297a984708SDavid Chisnall 18307a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 18317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18327a984708SDavid Chisnallvoid 18337a984708SDavid Chisnallfill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 18347a984708SDavid Chisnall{ 18357a984708SDavid Chisnall _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category()); 18367a984708SDavid Chisnall} 18377a984708SDavid Chisnall 18387a984708SDavid Chisnall// generate 18397a984708SDavid Chisnall 18407a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Generator> 18417a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18427a984708SDavid Chisnallvoid 18437a984708SDavid Chisnallgenerate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) 18447a984708SDavid Chisnall{ 18457a984708SDavid Chisnall for (; __first != __last; ++__first) 18467a984708SDavid Chisnall *__first = __gen(); 18477a984708SDavid Chisnall} 18487a984708SDavid Chisnall 18497a984708SDavid Chisnall// generate_n 18507a984708SDavid Chisnall 18517a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Generator> 18527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 18537a984708SDavid Chisnall_OutputIterator 18547a984708SDavid Chisnallgenerate_n(_OutputIterator __first, _Size __n, _Generator __gen) 18557a984708SDavid Chisnall{ 18567a984708SDavid Chisnall for (; __n > 0; ++__first, --__n) 18577a984708SDavid Chisnall *__first = __gen(); 18587a984708SDavid Chisnall return __first; 18597a984708SDavid Chisnall} 18607a984708SDavid Chisnall 18617a984708SDavid Chisnall// remove 18627a984708SDavid Chisnall 18637a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 18647a984708SDavid Chisnall_ForwardIterator 18657a984708SDavid Chisnallremove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 18667a984708SDavid Chisnall{ 18677a984708SDavid Chisnall __first = _VSTD::find(__first, __last, __value_); 18687a984708SDavid Chisnall if (__first != __last) 18697a984708SDavid Chisnall { 18707a984708SDavid Chisnall _ForwardIterator __i = __first; 18717a984708SDavid Chisnall while (++__i != __last) 18727a984708SDavid Chisnall { 18737a984708SDavid Chisnall if (!(*__i == __value_)) 18747a984708SDavid Chisnall { 18757a984708SDavid Chisnall *__first = _VSTD::move(*__i); 18767a984708SDavid Chisnall ++__first; 18777a984708SDavid Chisnall } 18787a984708SDavid Chisnall } 18797a984708SDavid Chisnall } 18807a984708SDavid Chisnall return __first; 18817a984708SDavid Chisnall} 18827a984708SDavid Chisnall 18837a984708SDavid Chisnall// remove_if 18847a984708SDavid Chisnall 18857a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate> 18867a984708SDavid Chisnall_ForwardIterator 18877a984708SDavid Chisnallremove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 18887a984708SDavid Chisnall{ 18897a984708SDavid Chisnall __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type> 18907a984708SDavid Chisnall (__first, __last, __pred); 18917a984708SDavid Chisnall if (__first != __last) 18927a984708SDavid Chisnall { 18937a984708SDavid Chisnall _ForwardIterator __i = __first; 18947a984708SDavid Chisnall while (++__i != __last) 18957a984708SDavid Chisnall { 18967a984708SDavid Chisnall if (!__pred(*__i)) 18977a984708SDavid Chisnall { 18987a984708SDavid Chisnall *__first = _VSTD::move(*__i); 18997a984708SDavid Chisnall ++__first; 19007a984708SDavid Chisnall } 19017a984708SDavid Chisnall } 19027a984708SDavid Chisnall } 19037a984708SDavid Chisnall return __first; 19047a984708SDavid Chisnall} 19057a984708SDavid Chisnall 19067a984708SDavid Chisnall// remove_copy 19077a984708SDavid Chisnall 19087a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Tp> 19097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19107a984708SDavid Chisnall_OutputIterator 19117a984708SDavid Chisnallremove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_) 19127a984708SDavid Chisnall{ 19137a984708SDavid Chisnall for (; __first != __last; ++__first) 19147a984708SDavid Chisnall { 19157a984708SDavid Chisnall if (!(*__first == __value_)) 19167a984708SDavid Chisnall { 19177a984708SDavid Chisnall *__result = *__first; 19187a984708SDavid Chisnall ++__result; 19197a984708SDavid Chisnall } 19207a984708SDavid Chisnall } 19217a984708SDavid Chisnall return __result; 19227a984708SDavid Chisnall} 19237a984708SDavid Chisnall 19247a984708SDavid Chisnall// remove_copy_if 19257a984708SDavid Chisnall 19267a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Predicate> 19277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19287a984708SDavid Chisnall_OutputIterator 19297a984708SDavid Chisnallremove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) 19307a984708SDavid Chisnall{ 19317a984708SDavid Chisnall for (; __first != __last; ++__first) 19327a984708SDavid Chisnall { 19337a984708SDavid Chisnall if (!__pred(*__first)) 19347a984708SDavid Chisnall { 19357a984708SDavid Chisnall *__result = *__first; 19367a984708SDavid Chisnall ++__result; 19377a984708SDavid Chisnall } 19387a984708SDavid Chisnall } 19397a984708SDavid Chisnall return __result; 19407a984708SDavid Chisnall} 19417a984708SDavid Chisnall 19427a984708SDavid Chisnall// unique 19437a984708SDavid Chisnall 19447a984708SDavid Chisnalltemplate <class _ForwardIterator, class _BinaryPredicate> 19457a984708SDavid Chisnall_ForwardIterator 19467a984708SDavid Chisnallunique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 19477a984708SDavid Chisnall{ 19487a984708SDavid Chisnall __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type> 19497a984708SDavid Chisnall (__first, __last, __pred); 19507a984708SDavid Chisnall if (__first != __last) 19517a984708SDavid Chisnall { 19527a984708SDavid Chisnall // ... a a ? ... 19537a984708SDavid Chisnall // f i 19547a984708SDavid Chisnall _ForwardIterator __i = __first; 19557a984708SDavid Chisnall for (++__i; ++__i != __last;) 19567a984708SDavid Chisnall if (!__pred(*__first, *__i)) 19577a984708SDavid Chisnall *++__first = _VSTD::move(*__i); 19587a984708SDavid Chisnall ++__first; 19597a984708SDavid Chisnall } 19607a984708SDavid Chisnall return __first; 19617a984708SDavid Chisnall} 19627a984708SDavid Chisnall 19637a984708SDavid Chisnalltemplate <class _ForwardIterator> 19647a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 19657a984708SDavid Chisnall_ForwardIterator 19667a984708SDavid Chisnallunique(_ForwardIterator __first, _ForwardIterator __last) 19677a984708SDavid Chisnall{ 19687a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type __v; 19697a984708SDavid Chisnall return _VSTD::unique(__first, __last, __equal_to<__v>()); 19707a984708SDavid Chisnall} 19717a984708SDavid Chisnall 19727a984708SDavid Chisnall// unique_copy 19737a984708SDavid Chisnall 19747a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator, class _OutputIterator> 19757a984708SDavid Chisnall_OutputIterator 19767a984708SDavid Chisnall__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 19777a984708SDavid Chisnall input_iterator_tag, output_iterator_tag) 19787a984708SDavid Chisnall{ 19797a984708SDavid Chisnall if (__first != __last) 19807a984708SDavid Chisnall { 19817a984708SDavid Chisnall typename iterator_traits<_InputIterator>::value_type __t(*__first); 19827a984708SDavid Chisnall *__result = __t; 19837a984708SDavid Chisnall ++__result; 19847a984708SDavid Chisnall while (++__first != __last) 19857a984708SDavid Chisnall { 19867a984708SDavid Chisnall if (!__pred(__t, *__first)) 19877a984708SDavid Chisnall { 19887a984708SDavid Chisnall __t = *__first; 19897a984708SDavid Chisnall *__result = __t; 19907a984708SDavid Chisnall ++__result; 19917a984708SDavid Chisnall } 19927a984708SDavid Chisnall } 19937a984708SDavid Chisnall } 19947a984708SDavid Chisnall return __result; 19957a984708SDavid Chisnall} 19967a984708SDavid Chisnall 19977a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator> 19987a984708SDavid Chisnall_OutputIterator 19997a984708SDavid Chisnall__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 20007a984708SDavid Chisnall forward_iterator_tag, output_iterator_tag) 20017a984708SDavid Chisnall{ 20027a984708SDavid Chisnall if (__first != __last) 20037a984708SDavid Chisnall { 20047a984708SDavid Chisnall _ForwardIterator __i = __first; 20057a984708SDavid Chisnall *__result = *__i; 20067a984708SDavid Chisnall ++__result; 20077a984708SDavid Chisnall while (++__first != __last) 20087a984708SDavid Chisnall { 20097a984708SDavid Chisnall if (!__pred(*__i, *__first)) 20107a984708SDavid Chisnall { 20117a984708SDavid Chisnall *__result = *__first; 20127a984708SDavid Chisnall ++__result; 20137a984708SDavid Chisnall __i = __first; 20147a984708SDavid Chisnall } 20157a984708SDavid Chisnall } 20167a984708SDavid Chisnall } 20177a984708SDavid Chisnall return __result; 20187a984708SDavid Chisnall} 20197a984708SDavid Chisnall 20207a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator, class _ForwardIterator> 20217a984708SDavid Chisnall_ForwardIterator 20227a984708SDavid Chisnall__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred, 20237a984708SDavid Chisnall input_iterator_tag, forward_iterator_tag) 20247a984708SDavid Chisnall{ 20257a984708SDavid Chisnall if (__first != __last) 20267a984708SDavid Chisnall { 20277a984708SDavid Chisnall *__result = *__first; 20287a984708SDavid Chisnall while (++__first != __last) 20297a984708SDavid Chisnall if (!__pred(*__result, *__first)) 20307a984708SDavid Chisnall *++__result = *__first; 20317a984708SDavid Chisnall ++__result; 20327a984708SDavid Chisnall } 20337a984708SDavid Chisnall return __result; 20347a984708SDavid Chisnall} 20357a984708SDavid Chisnall 20367a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _BinaryPredicate> 20377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20387a984708SDavid Chisnall_OutputIterator 20397a984708SDavid Chisnallunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) 20407a984708SDavid Chisnall{ 20417a984708SDavid Chisnall return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type> 20427a984708SDavid Chisnall (__first, __last, __result, __pred, 20437a984708SDavid Chisnall typename iterator_traits<_InputIterator>::iterator_category(), 20447a984708SDavid Chisnall typename iterator_traits<_OutputIterator>::iterator_category()); 20457a984708SDavid Chisnall} 20467a984708SDavid Chisnall 20477a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator> 20487a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20497a984708SDavid Chisnall_OutputIterator 20507a984708SDavid Chisnallunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 20517a984708SDavid Chisnall{ 20527a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator>::value_type __v; 20537a984708SDavid Chisnall return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>()); 20547a984708SDavid Chisnall} 20557a984708SDavid Chisnall 20567a984708SDavid Chisnall// reverse 20577a984708SDavid Chisnall 20587a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 20597a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20607a984708SDavid Chisnallvoid 20617a984708SDavid Chisnall__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) 20627a984708SDavid Chisnall{ 20637a984708SDavid Chisnall while (__first != __last) 20647a984708SDavid Chisnall { 20657a984708SDavid Chisnall if (__first == --__last) 20667a984708SDavid Chisnall break; 20677a984708SDavid Chisnall swap(*__first, *__last); 20687a984708SDavid Chisnall ++__first; 20697a984708SDavid Chisnall } 20707a984708SDavid Chisnall} 20717a984708SDavid Chisnall 20727a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 20737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20747a984708SDavid Chisnallvoid 20757a984708SDavid Chisnall__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) 20767a984708SDavid Chisnall{ 20777a984708SDavid Chisnall if (__first != __last) 20787a984708SDavid Chisnall for (; __first < --__last; ++__first) 20797a984708SDavid Chisnall swap(*__first, *__last); 20807a984708SDavid Chisnall} 20817a984708SDavid Chisnall 20827a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 20837a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20847a984708SDavid Chisnallvoid 20857a984708SDavid Chisnallreverse(_BidirectionalIterator __first, _BidirectionalIterator __last) 20867a984708SDavid Chisnall{ 20877a984708SDavid Chisnall _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category()); 20887a984708SDavid Chisnall} 20897a984708SDavid Chisnall 20907a984708SDavid Chisnall// reverse_copy 20917a984708SDavid Chisnall 20927a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _OutputIterator> 20937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 20947a984708SDavid Chisnall_OutputIterator 20957a984708SDavid Chisnallreverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 20967a984708SDavid Chisnall{ 20977a984708SDavid Chisnall for (; __first != __last; ++__result) 20987a984708SDavid Chisnall *__result = *--__last; 20997a984708SDavid Chisnall return __result; 21007a984708SDavid Chisnall} 21017a984708SDavid Chisnall 21027a984708SDavid Chisnall// rotate 21037a984708SDavid Chisnall 21047a984708SDavid Chisnalltemplate <class _ForwardIterator> 21057a984708SDavid Chisnall_ForwardIterator 2106936e9439SDimitry Andric__rotate_left(_ForwardIterator __first, _ForwardIterator __last) 21077a984708SDavid Chisnall{ 2108936e9439SDimitry Andric typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 2109936e9439SDimitry Andric value_type __tmp = _VSTD::move(*__first); 2110936e9439SDimitry Andric _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first); 2111936e9439SDimitry Andric *__lm1 = _VSTD::move(__tmp); 2112936e9439SDimitry Andric return __lm1; 2113936e9439SDimitry Andric} 2114936e9439SDimitry Andric 2115936e9439SDimitry Andrictemplate <class _BidirectionalIterator> 2116936e9439SDimitry Andric_BidirectionalIterator 2117936e9439SDimitry Andric__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) 2118936e9439SDimitry Andric{ 2119936e9439SDimitry Andric typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 2120936e9439SDimitry Andric _BidirectionalIterator __lm1 = _VSTD::prev(__last); 2121936e9439SDimitry Andric value_type __tmp = _VSTD::move(*__lm1); 2122936e9439SDimitry Andric _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last); 2123936e9439SDimitry Andric *__first = _VSTD::move(__tmp); 2124936e9439SDimitry Andric return __fp1; 2125936e9439SDimitry Andric} 2126936e9439SDimitry Andric 2127936e9439SDimitry Andrictemplate <class _ForwardIterator> 2128936e9439SDimitry Andric_ForwardIterator 2129936e9439SDimitry Andric__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 2130936e9439SDimitry Andric{ 21317a984708SDavid Chisnall _ForwardIterator __i = __middle; 21327a984708SDavid Chisnall while (true) 21337a984708SDavid Chisnall { 21347a984708SDavid Chisnall swap(*__first, *__i); 21357a984708SDavid Chisnall ++__first; 21367a984708SDavid Chisnall if (++__i == __last) 21377a984708SDavid Chisnall break; 21387a984708SDavid Chisnall if (__first == __middle) 21397a984708SDavid Chisnall __middle = __i; 21407a984708SDavid Chisnall } 21417a984708SDavid Chisnall _ForwardIterator __r = __first; 21427a984708SDavid Chisnall if (__first != __middle) 21437a984708SDavid Chisnall { 21447a984708SDavid Chisnall __i = __middle; 21457a984708SDavid Chisnall while (true) 21467a984708SDavid Chisnall { 21477a984708SDavid Chisnall swap(*__first, *__i); 21487a984708SDavid Chisnall ++__first; 21497a984708SDavid Chisnall if (++__i == __last) 21507a984708SDavid Chisnall { 21517a984708SDavid Chisnall if (__first == __middle) 21527a984708SDavid Chisnall break; 21537a984708SDavid Chisnall __i = __middle; 21547a984708SDavid Chisnall } 21557a984708SDavid Chisnall else if (__first == __middle) 21567a984708SDavid Chisnall __middle = __i; 21577a984708SDavid Chisnall } 21587a984708SDavid Chisnall } 21597a984708SDavid Chisnall return __r; 21607a984708SDavid Chisnall} 21617a984708SDavid Chisnall 21627a984708SDavid Chisnalltemplate<typename _Integral> 21637a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 21647a984708SDavid Chisnall_Integral 21657a984708SDavid Chisnall__gcd(_Integral __x, _Integral __y) 21667a984708SDavid Chisnall{ 21677a984708SDavid Chisnall do 21687a984708SDavid Chisnall { 21697a984708SDavid Chisnall _Integral __t = __x % __y; 21707a984708SDavid Chisnall __x = __y; 21717a984708SDavid Chisnall __y = __t; 21727a984708SDavid Chisnall } while (__y); 21737a984708SDavid Chisnall return __x; 21747a984708SDavid Chisnall} 21757a984708SDavid Chisnall 21767a984708SDavid Chisnalltemplate<typename _RandomAccessIterator> 21777a984708SDavid Chisnall_RandomAccessIterator 2178936e9439SDimitry Andric__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 21797a984708SDavid Chisnall{ 21807a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 21817a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 21827a984708SDavid Chisnall 21837a984708SDavid Chisnall const difference_type __m1 = __middle - __first; 21847a984708SDavid Chisnall const difference_type __m2 = __last - __middle; 21857a984708SDavid Chisnall if (__m1 == __m2) 21867a984708SDavid Chisnall { 21877a984708SDavid Chisnall _VSTD::swap_ranges(__first, __middle, __middle); 21887a984708SDavid Chisnall return __middle; 21897a984708SDavid Chisnall } 2190936e9439SDimitry Andric const difference_type __g = _VSTD::__gcd(__m1, __m2); 21917a984708SDavid Chisnall for (_RandomAccessIterator __p = __first + __g; __p != __first;) 21927a984708SDavid Chisnall { 2193936e9439SDimitry Andric value_type __t(_VSTD::move(*--__p)); 21947a984708SDavid Chisnall _RandomAccessIterator __p1 = __p; 21957a984708SDavid Chisnall _RandomAccessIterator __p2 = __p1 + __m1; 21967a984708SDavid Chisnall do 21977a984708SDavid Chisnall { 2198936e9439SDimitry Andric *__p1 = _VSTD::move(*__p2); 21997a984708SDavid Chisnall __p1 = __p2; 22007a984708SDavid Chisnall const difference_type __d = __last - __p2; 22017a984708SDavid Chisnall if (__m1 < __d) 22027a984708SDavid Chisnall __p2 += __m1; 22037a984708SDavid Chisnall else 22047a984708SDavid Chisnall __p2 = __first + (__m1 - __d); 22057a984708SDavid Chisnall } while (__p2 != __p); 2206936e9439SDimitry Andric *__p1 = _VSTD::move(__t); 22077a984708SDavid Chisnall } 22087a984708SDavid Chisnall return __first + __m2; 22097a984708SDavid Chisnall} 22107a984708SDavid Chisnall 22117a984708SDavid Chisnalltemplate <class _ForwardIterator> 22127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22137a984708SDavid Chisnall_ForwardIterator 2214936e9439SDimitry Andric__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, 2215936e9439SDimitry Andric _VSTD::forward_iterator_tag) 2216936e9439SDimitry Andric{ 2217936e9439SDimitry Andric typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type; 2218936e9439SDimitry Andric if (_VSTD::is_trivially_move_assignable<value_type>::value) 2219936e9439SDimitry Andric { 2220936e9439SDimitry Andric if (_VSTD::next(__first) == __middle) 2221936e9439SDimitry Andric return _VSTD::__rotate_left(__first, __last); 2222936e9439SDimitry Andric } 2223936e9439SDimitry Andric return _VSTD::__rotate_forward(__first, __middle, __last); 2224936e9439SDimitry Andric} 2225936e9439SDimitry Andric 2226936e9439SDimitry Andrictemplate <class _BidirectionalIterator> 2227936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 2228936e9439SDimitry Andric_BidirectionalIterator 2229936e9439SDimitry Andric__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 2230936e9439SDimitry Andric _VSTD::bidirectional_iterator_tag) 2231936e9439SDimitry Andric{ 2232936e9439SDimitry Andric typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type; 2233936e9439SDimitry Andric if (_VSTD::is_trivially_move_assignable<value_type>::value) 2234936e9439SDimitry Andric { 2235936e9439SDimitry Andric if (_VSTD::next(__first) == __middle) 2236936e9439SDimitry Andric return _VSTD::__rotate_left(__first, __last); 2237936e9439SDimitry Andric if (_VSTD::next(__middle) == __last) 2238936e9439SDimitry Andric return _VSTD::__rotate_right(__first, __last); 2239936e9439SDimitry Andric } 2240936e9439SDimitry Andric return _VSTD::__rotate_forward(__first, __middle, __last); 2241936e9439SDimitry Andric} 2242936e9439SDimitry Andric 2243936e9439SDimitry Andrictemplate <class _RandomAccessIterator> 2244936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 2245936e9439SDimitry Andric_RandomAccessIterator 2246936e9439SDimitry Andric__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 2247936e9439SDimitry Andric _VSTD::random_access_iterator_tag) 2248936e9439SDimitry Andric{ 2249936e9439SDimitry Andric typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type; 2250936e9439SDimitry Andric if (_VSTD::is_trivially_move_assignable<value_type>::value) 2251936e9439SDimitry Andric { 2252936e9439SDimitry Andric if (_VSTD::next(__first) == __middle) 2253936e9439SDimitry Andric return _VSTD::__rotate_left(__first, __last); 2254936e9439SDimitry Andric if (_VSTD::next(__middle) == __last) 2255936e9439SDimitry Andric return _VSTD::__rotate_right(__first, __last); 2256936e9439SDimitry Andric return _VSTD::__rotate_gcd(__first, __middle, __last); 2257936e9439SDimitry Andric } 2258936e9439SDimitry Andric return _VSTD::__rotate_forward(__first, __middle, __last); 2259936e9439SDimitry Andric} 2260936e9439SDimitry Andric 2261936e9439SDimitry Andrictemplate <class _ForwardIterator> 2262936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 2263936e9439SDimitry Andric_ForwardIterator 22647a984708SDavid Chisnallrotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 22657a984708SDavid Chisnall{ 2266936e9439SDimitry Andric if (__first == __middle) 2267936e9439SDimitry Andric return __last; 2268936e9439SDimitry Andric if (__middle == __last) 2269936e9439SDimitry Andric return __first; 22707a984708SDavid Chisnall return _VSTD::__rotate(__first, __middle, __last, 2271936e9439SDimitry Andric typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category()); 22727a984708SDavid Chisnall} 22737a984708SDavid Chisnall 22747a984708SDavid Chisnall// rotate_copy 22757a984708SDavid Chisnall 22767a984708SDavid Chisnalltemplate <class _ForwardIterator, class _OutputIterator> 22777a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22787a984708SDavid Chisnall_OutputIterator 22797a984708SDavid Chisnallrotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) 22807a984708SDavid Chisnall{ 22817a984708SDavid Chisnall return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result)); 22827a984708SDavid Chisnall} 22837a984708SDavid Chisnall 22847a984708SDavid Chisnall// min_element 22857a984708SDavid Chisnall 22867a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 22877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 22887a984708SDavid Chisnall_ForwardIterator 22897a984708SDavid Chisnallmin_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 22907a984708SDavid Chisnall{ 22917a984708SDavid Chisnall if (__first != __last) 22927a984708SDavid Chisnall { 22937a984708SDavid Chisnall _ForwardIterator __i = __first; 22947a984708SDavid Chisnall while (++__i != __last) 22957a984708SDavid Chisnall if (__comp(*__i, *__first)) 22967a984708SDavid Chisnall __first = __i; 22977a984708SDavid Chisnall } 22987a984708SDavid Chisnall return __first; 22997a984708SDavid Chisnall} 23007a984708SDavid Chisnall 23017a984708SDavid Chisnalltemplate <class _ForwardIterator> 23027a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23037a984708SDavid Chisnall_ForwardIterator 23047a984708SDavid Chisnallmin_element(_ForwardIterator __first, _ForwardIterator __last) 23057a984708SDavid Chisnall{ 23067a984708SDavid Chisnall return _VSTD::min_element(__first, __last, 23077a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type>()); 23087a984708SDavid Chisnall} 23097a984708SDavid Chisnall 23107a984708SDavid Chisnall// min 23117a984708SDavid Chisnall 23127a984708SDavid Chisnalltemplate <class _Tp, class _Compare> 23137a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23147a984708SDavid Chisnallconst _Tp& 23157a984708SDavid Chisnallmin(const _Tp& __a, const _Tp& __b, _Compare __comp) 23167a984708SDavid Chisnall{ 23177a984708SDavid Chisnall return __comp(__b, __a) ? __b : __a; 23187a984708SDavid Chisnall} 23197a984708SDavid Chisnall 23207a984708SDavid Chisnalltemplate <class _Tp> 23217a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23227a984708SDavid Chisnallconst _Tp& 23237a984708SDavid Chisnallmin(const _Tp& __a, const _Tp& __b) 23247a984708SDavid Chisnall{ 23257a984708SDavid Chisnall return _VSTD::min(__a, __b, __less<_Tp>()); 23267a984708SDavid Chisnall} 23277a984708SDavid Chisnall 23287a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 23297a984708SDavid Chisnall 23307a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 23317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23327a984708SDavid Chisnall_Tp 23337a984708SDavid Chisnallmin(initializer_list<_Tp> __t, _Compare __comp) 23347a984708SDavid Chisnall{ 23357a984708SDavid Chisnall return *_VSTD::min_element(__t.begin(), __t.end(), __comp); 23367a984708SDavid Chisnall} 23377a984708SDavid Chisnall 23387a984708SDavid Chisnalltemplate<class _Tp> 23397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23407a984708SDavid Chisnall_Tp 23417a984708SDavid Chisnallmin(initializer_list<_Tp> __t) 23427a984708SDavid Chisnall{ 23437a984708SDavid Chisnall return *_VSTD::min_element(__t.begin(), __t.end()); 23447a984708SDavid Chisnall} 23457a984708SDavid Chisnall 23467a984708SDavid Chisnall#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 23477a984708SDavid Chisnall 23487a984708SDavid Chisnall// max_element 23497a984708SDavid Chisnall 23507a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 23517a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23527a984708SDavid Chisnall_ForwardIterator 23537a984708SDavid Chisnallmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 23547a984708SDavid Chisnall{ 23557a984708SDavid Chisnall if (__first != __last) 23567a984708SDavid Chisnall { 23577a984708SDavid Chisnall _ForwardIterator __i = __first; 23587a984708SDavid Chisnall while (++__i != __last) 23597a984708SDavid Chisnall if (__comp(*__first, *__i)) 23607a984708SDavid Chisnall __first = __i; 23617a984708SDavid Chisnall } 23627a984708SDavid Chisnall return __first; 23637a984708SDavid Chisnall} 23647a984708SDavid Chisnall 23657a984708SDavid Chisnalltemplate <class _ForwardIterator> 23667a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23677a984708SDavid Chisnall_ForwardIterator 23687a984708SDavid Chisnallmax_element(_ForwardIterator __first, _ForwardIterator __last) 23697a984708SDavid Chisnall{ 23707a984708SDavid Chisnall return _VSTD::max_element(__first, __last, 23717a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type>()); 23727a984708SDavid Chisnall} 23737a984708SDavid Chisnall 23747a984708SDavid Chisnall// max 23757a984708SDavid Chisnall 23767a984708SDavid Chisnalltemplate <class _Tp, class _Compare> 23777a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23787a984708SDavid Chisnallconst _Tp& 23797a984708SDavid Chisnallmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 23807a984708SDavid Chisnall{ 23817a984708SDavid Chisnall return __comp(__a, __b) ? __b : __a; 23827a984708SDavid Chisnall} 23837a984708SDavid Chisnall 23847a984708SDavid Chisnalltemplate <class _Tp> 23857a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23867a984708SDavid Chisnallconst _Tp& 23877a984708SDavid Chisnallmax(const _Tp& __a, const _Tp& __b) 23887a984708SDavid Chisnall{ 23897a984708SDavid Chisnall return _VSTD::max(__a, __b, __less<_Tp>()); 23907a984708SDavid Chisnall} 23917a984708SDavid Chisnall 23927a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 23937a984708SDavid Chisnall 23947a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 23957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 23967a984708SDavid Chisnall_Tp 23977a984708SDavid Chisnallmax(initializer_list<_Tp> __t, _Compare __comp) 23987a984708SDavid Chisnall{ 23997a984708SDavid Chisnall return *_VSTD::max_element(__t.begin(), __t.end(), __comp); 24007a984708SDavid Chisnall} 24017a984708SDavid Chisnall 24027a984708SDavid Chisnalltemplate<class _Tp> 24037a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 24047a984708SDavid Chisnall_Tp 24057a984708SDavid Chisnallmax(initializer_list<_Tp> __t) 24067a984708SDavid Chisnall{ 24077a984708SDavid Chisnall return *_VSTD::max_element(__t.begin(), __t.end()); 24087a984708SDavid Chisnall} 24097a984708SDavid Chisnall 24107a984708SDavid Chisnall#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 24117a984708SDavid Chisnall 24127a984708SDavid Chisnall// minmax_element 24137a984708SDavid Chisnall 24147a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 24157a984708SDavid Chisnallstd::pair<_ForwardIterator, _ForwardIterator> 24167a984708SDavid Chisnallminmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 24177a984708SDavid Chisnall{ 24187a984708SDavid Chisnall std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first); 24197a984708SDavid Chisnall if (__first != __last) 24207a984708SDavid Chisnall { 24217a984708SDavid Chisnall if (++__first != __last) 24227a984708SDavid Chisnall { 24237a984708SDavid Chisnall if (__comp(*__first, *__result.first)) 24247a984708SDavid Chisnall __result.first = __first; 24257a984708SDavid Chisnall else 24267a984708SDavid Chisnall __result.second = __first; 24277a984708SDavid Chisnall while (++__first != __last) 24287a984708SDavid Chisnall { 24297a984708SDavid Chisnall _ForwardIterator __i = __first; 24307a984708SDavid Chisnall if (++__first == __last) 24317a984708SDavid Chisnall { 24327a984708SDavid Chisnall if (__comp(*__i, *__result.first)) 24337a984708SDavid Chisnall __result.first = __i; 24347a984708SDavid Chisnall else if (!__comp(*__i, *__result.second)) 24357a984708SDavid Chisnall __result.second = __i; 24367a984708SDavid Chisnall break; 24377a984708SDavid Chisnall } 24387a984708SDavid Chisnall else 24397a984708SDavid Chisnall { 24407a984708SDavid Chisnall if (__comp(*__first, *__i)) 24417a984708SDavid Chisnall { 24427a984708SDavid Chisnall if (__comp(*__first, *__result.first)) 24437a984708SDavid Chisnall __result.first = __first; 24447a984708SDavid Chisnall if (!__comp(*__i, *__result.second)) 24457a984708SDavid Chisnall __result.second = __i; 24467a984708SDavid Chisnall } 24477a984708SDavid Chisnall else 24487a984708SDavid Chisnall { 24497a984708SDavid Chisnall if (__comp(*__i, *__result.first)) 24507a984708SDavid Chisnall __result.first = __i; 24517a984708SDavid Chisnall if (!__comp(*__first, *__result.second)) 24527a984708SDavid Chisnall __result.second = __first; 24537a984708SDavid Chisnall } 24547a984708SDavid Chisnall } 24557a984708SDavid Chisnall } 24567a984708SDavid Chisnall } 24577a984708SDavid Chisnall } 24587a984708SDavid Chisnall return __result; 24597a984708SDavid Chisnall} 24607a984708SDavid Chisnall 24617a984708SDavid Chisnalltemplate <class _ForwardIterator> 24627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 24637a984708SDavid Chisnallstd::pair<_ForwardIterator, _ForwardIterator> 24647a984708SDavid Chisnallminmax_element(_ForwardIterator __first, _ForwardIterator __last) 24657a984708SDavid Chisnall{ 24667a984708SDavid Chisnall return _VSTD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 24677a984708SDavid Chisnall} 24687a984708SDavid Chisnall 24697a984708SDavid Chisnall// minmax 24707a984708SDavid Chisnall 24717a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 24727a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 24737a984708SDavid Chisnallpair<const _Tp&, const _Tp&> 24747a984708SDavid Chisnallminmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 24757a984708SDavid Chisnall{ 24767a984708SDavid Chisnall return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) : 24777a984708SDavid Chisnall pair<const _Tp&, const _Tp&>(__a, __b); 24787a984708SDavid Chisnall} 24797a984708SDavid Chisnall 24807a984708SDavid Chisnalltemplate<class _Tp> 24817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 24827a984708SDavid Chisnallpair<const _Tp&, const _Tp&> 24837a984708SDavid Chisnallminmax(const _Tp& __a, const _Tp& __b) 24847a984708SDavid Chisnall{ 24857a984708SDavid Chisnall return _VSTD::minmax(__a, __b, __less<_Tp>()); 24867a984708SDavid Chisnall} 24877a984708SDavid Chisnall 24887a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 24897a984708SDavid Chisnall 24907a984708SDavid Chisnalltemplate<class _Tp> 24917a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 24927a984708SDavid Chisnallpair<_Tp, _Tp> 24937a984708SDavid Chisnallminmax(initializer_list<_Tp> __t) 24947a984708SDavid Chisnall{ 24957a984708SDavid Chisnall pair<const _Tp*, const _Tp*> __p = 24967a984708SDavid Chisnall _VSTD::minmax_element(__t.begin(), __t.end()); 24977a984708SDavid Chisnall return pair<_Tp, _Tp>(*__p.first, *__p.second); 24987a984708SDavid Chisnall} 24997a984708SDavid Chisnall 25007a984708SDavid Chisnalltemplate<class _Tp, class _Compare> 25017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 25027a984708SDavid Chisnallpair<_Tp, _Tp> 25037a984708SDavid Chisnallminmax(initializer_list<_Tp> __t, _Compare __comp) 25047a984708SDavid Chisnall{ 25057a984708SDavid Chisnall pair<const _Tp*, const _Tp*> __p = 25067a984708SDavid Chisnall _VSTD::minmax_element(__t.begin(), __t.end(), __comp); 25077a984708SDavid Chisnall return pair<_Tp, _Tp>(*__p.first, *__p.second); 25087a984708SDavid Chisnall} 25097a984708SDavid Chisnall 25107a984708SDavid Chisnall#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 25117a984708SDavid Chisnall 25127a984708SDavid Chisnall// random_shuffle 25137a984708SDavid Chisnall 25147a984708SDavid Chisnall// __independent_bits_engine 25157a984708SDavid Chisnall 251694e3ee44SDavid Chisnalltemplate <unsigned long long _Xp, size_t _Rp> 25177a984708SDavid Chisnallstruct __log2_imp 25187a984708SDavid Chisnall{ 251994e3ee44SDavid Chisnall static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp 252094e3ee44SDavid Chisnall : __log2_imp<_Xp, _Rp - 1>::value; 25217a984708SDavid Chisnall}; 25227a984708SDavid Chisnall 252394e3ee44SDavid Chisnalltemplate <unsigned long long _Xp> 252494e3ee44SDavid Chisnallstruct __log2_imp<_Xp, 0> 25257a984708SDavid Chisnall{ 25267a984708SDavid Chisnall static const size_t value = 0; 25277a984708SDavid Chisnall}; 25287a984708SDavid Chisnall 252994e3ee44SDavid Chisnalltemplate <size_t _Rp> 253094e3ee44SDavid Chisnallstruct __log2_imp<0, _Rp> 25317a984708SDavid Chisnall{ 253294e3ee44SDavid Chisnall static const size_t value = _Rp + 1; 25337a984708SDavid Chisnall}; 25347a984708SDavid Chisnall 253594e3ee44SDavid Chisnalltemplate <class _UI, _UI _Xp> 25367a984708SDavid Chisnallstruct __log2 25377a984708SDavid Chisnall{ 253894e3ee44SDavid Chisnall static const size_t value = __log2_imp<_Xp, 25397a984708SDavid Chisnall sizeof(_UI) * __CHAR_BIT__ - 1>::value; 25407a984708SDavid Chisnall}; 25417a984708SDavid Chisnall 25427a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 25437a984708SDavid Chisnallclass __independent_bits_engine 25447a984708SDavid Chisnall{ 25457a984708SDavid Chisnallpublic: 25467a984708SDavid Chisnall // types 25477a984708SDavid Chisnall typedef _UIntType result_type; 25487a984708SDavid Chisnall 25497a984708SDavid Chisnallprivate: 25507a984708SDavid Chisnall typedef typename _Engine::result_type _Engine_result_type; 25517a984708SDavid Chisnall typedef typename conditional 25527a984708SDavid Chisnall < 25537a984708SDavid Chisnall sizeof(_Engine_result_type) <= sizeof(result_type), 25547a984708SDavid Chisnall result_type, 25557a984708SDavid Chisnall _Engine_result_type 25567a984708SDavid Chisnall >::type _Working_result_type; 25577a984708SDavid Chisnall 25587a984708SDavid Chisnall _Engine& __e_; 25597a984708SDavid Chisnall size_t __w_; 25607a984708SDavid Chisnall size_t __w0_; 25617a984708SDavid Chisnall size_t __n_; 25627a984708SDavid Chisnall size_t __n0_; 25637a984708SDavid Chisnall _Working_result_type __y0_; 25647a984708SDavid Chisnall _Working_result_type __y1_; 25657a984708SDavid Chisnall _Engine_result_type __mask0_; 25667a984708SDavid Chisnall _Engine_result_type __mask1_; 25677a984708SDavid Chisnall 2568b03f91a8SDavid Chisnall#ifdef _LIBCPP_HAS_NO_CONSTEXPR 256994e3ee44SDavid Chisnall static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min 25707a984708SDavid Chisnall + _Working_result_type(1); 2571b03f91a8SDavid Chisnall#else 2572b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() 2573b03f91a8SDavid Chisnall + _Working_result_type(1); 2574b03f91a8SDavid Chisnall#endif 2575b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value; 2576b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits; 2577b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; 25787a984708SDavid Chisnall 25797a984708SDavid Chisnallpublic: 25807a984708SDavid Chisnall // constructors and seeding functions 25817a984708SDavid Chisnall __independent_bits_engine(_Engine& __e, size_t __w); 25827a984708SDavid Chisnall 25837a984708SDavid Chisnall // generating functions 258494e3ee44SDavid Chisnall result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());} 25857a984708SDavid Chisnall 25867a984708SDavid Chisnallprivate: 25877a984708SDavid Chisnall result_type __eval(false_type); 25887a984708SDavid Chisnall result_type __eval(true_type); 25897a984708SDavid Chisnall}; 25907a984708SDavid Chisnall 25917a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 25927a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType> 25937a984708SDavid Chisnall ::__independent_bits_engine(_Engine& __e, size_t __w) 25947a984708SDavid Chisnall : __e_(__e), 25957a984708SDavid Chisnall __w_(__w) 25967a984708SDavid Chisnall{ 25977a984708SDavid Chisnall __n_ = __w_ / __m + (__w_ % __m != 0); 25987a984708SDavid Chisnall __w0_ = __w_ / __n_; 259994e3ee44SDavid Chisnall if (_Rp == 0) 260094e3ee44SDavid Chisnall __y0_ = _Rp; 26017a984708SDavid Chisnall else if (__w0_ < _WDt) 260294e3ee44SDavid Chisnall __y0_ = (_Rp >> __w0_) << __w0_; 26037a984708SDavid Chisnall else 26047a984708SDavid Chisnall __y0_ = 0; 260594e3ee44SDavid Chisnall if (_Rp - __y0_ > __y0_ / __n_) 26067a984708SDavid Chisnall { 26077a984708SDavid Chisnall ++__n_; 26087a984708SDavid Chisnall __w0_ = __w_ / __n_; 26097a984708SDavid Chisnall if (__w0_ < _WDt) 261094e3ee44SDavid Chisnall __y0_ = (_Rp >> __w0_) << __w0_; 26117a984708SDavid Chisnall else 26127a984708SDavid Chisnall __y0_ = 0; 26137a984708SDavid Chisnall } 26147a984708SDavid Chisnall __n0_ = __n_ - __w_ % __n_; 26157a984708SDavid Chisnall if (__w0_ < _WDt - 1) 261694e3ee44SDavid Chisnall __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1); 26177a984708SDavid Chisnall else 26187a984708SDavid Chisnall __y1_ = 0; 26197a984708SDavid Chisnall __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) : 26207a984708SDavid Chisnall _Engine_result_type(0); 26217a984708SDavid Chisnall __mask1_ = __w0_ < _EDt - 1 ? 26227a984708SDavid Chisnall _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) : 26237a984708SDavid Chisnall _Engine_result_type(~0); 26247a984708SDavid Chisnall} 26257a984708SDavid Chisnall 26267a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 26277a984708SDavid Chisnallinline 26287a984708SDavid Chisnall_UIntType 26297a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>::__eval(false_type) 26307a984708SDavid Chisnall{ 26317a984708SDavid Chisnall return static_cast<result_type>(__e_() & __mask0_); 26327a984708SDavid Chisnall} 26337a984708SDavid Chisnall 26347a984708SDavid Chisnalltemplate<class _Engine, class _UIntType> 26357a984708SDavid Chisnall_UIntType 26367a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>::__eval(true_type) 26377a984708SDavid Chisnall{ 263894e3ee44SDavid Chisnall result_type _Sp = 0; 26397a984708SDavid Chisnall for (size_t __k = 0; __k < __n0_; ++__k) 26407a984708SDavid Chisnall { 26417a984708SDavid Chisnall _Engine_result_type __u; 26427a984708SDavid Chisnall do 26437a984708SDavid Chisnall { 26447a984708SDavid Chisnall __u = __e_() - _Engine::min(); 26457a984708SDavid Chisnall } while (__u >= __y0_); 26467a984708SDavid Chisnall if (__w0_ < _WDt) 264794e3ee44SDavid Chisnall _Sp <<= __w0_; 26487a984708SDavid Chisnall else 264994e3ee44SDavid Chisnall _Sp = 0; 265094e3ee44SDavid Chisnall _Sp += __u & __mask0_; 26517a984708SDavid Chisnall } 26527a984708SDavid Chisnall for (size_t __k = __n0_; __k < __n_; ++__k) 26537a984708SDavid Chisnall { 26547a984708SDavid Chisnall _Engine_result_type __u; 26557a984708SDavid Chisnall do 26567a984708SDavid Chisnall { 26577a984708SDavid Chisnall __u = __e_() - _Engine::min(); 26587a984708SDavid Chisnall } while (__u >= __y1_); 26597a984708SDavid Chisnall if (__w0_ < _WDt - 1) 266094e3ee44SDavid Chisnall _Sp <<= __w0_ + 1; 26617a984708SDavid Chisnall else 266294e3ee44SDavid Chisnall _Sp = 0; 266394e3ee44SDavid Chisnall _Sp += __u & __mask1_; 26647a984708SDavid Chisnall } 266594e3ee44SDavid Chisnall return _Sp; 26667a984708SDavid Chisnall} 26677a984708SDavid Chisnall 26687a984708SDavid Chisnall// uniform_int_distribution 26697a984708SDavid Chisnall 26707a984708SDavid Chisnalltemplate<class _IntType = int> 26717a984708SDavid Chisnallclass uniform_int_distribution 26727a984708SDavid Chisnall{ 26737a984708SDavid Chisnallpublic: 26747a984708SDavid Chisnall // types 26757a984708SDavid Chisnall typedef _IntType result_type; 26767a984708SDavid Chisnall 26777a984708SDavid Chisnall class param_type 26787a984708SDavid Chisnall { 26797a984708SDavid Chisnall result_type __a_; 26807a984708SDavid Chisnall result_type __b_; 26817a984708SDavid Chisnall public: 26827a984708SDavid Chisnall typedef uniform_int_distribution distribution_type; 26837a984708SDavid Chisnall 26847a984708SDavid Chisnall explicit param_type(result_type __a = 0, 26857a984708SDavid Chisnall result_type __b = numeric_limits<result_type>::max()) 26867a984708SDavid Chisnall : __a_(__a), __b_(__b) {} 26877a984708SDavid Chisnall 26887a984708SDavid Chisnall result_type a() const {return __a_;} 26897a984708SDavid Chisnall result_type b() const {return __b_;} 26907a984708SDavid Chisnall 26917a984708SDavid Chisnall friend bool operator==(const param_type& __x, const param_type& __y) 26927a984708SDavid Chisnall {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} 26937a984708SDavid Chisnall friend bool operator!=(const param_type& __x, const param_type& __y) 26947a984708SDavid Chisnall {return !(__x == __y);} 26957a984708SDavid Chisnall }; 26967a984708SDavid Chisnall 26977a984708SDavid Chisnallprivate: 26987a984708SDavid Chisnall param_type __p_; 26997a984708SDavid Chisnall 27007a984708SDavid Chisnallpublic: 27017a984708SDavid Chisnall // constructors and reset functions 27027a984708SDavid Chisnall explicit uniform_int_distribution(result_type __a = 0, 27037a984708SDavid Chisnall result_type __b = numeric_limits<result_type>::max()) 27047a984708SDavid Chisnall : __p_(param_type(__a, __b)) {} 27057a984708SDavid Chisnall explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {} 27067a984708SDavid Chisnall void reset() {} 27077a984708SDavid Chisnall 27087a984708SDavid Chisnall // generating functions 27097a984708SDavid Chisnall template<class _URNG> result_type operator()(_URNG& __g) 27107a984708SDavid Chisnall {return (*this)(__g, __p_);} 27117a984708SDavid Chisnall template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p); 27127a984708SDavid Chisnall 27137a984708SDavid Chisnall // property functions 27147a984708SDavid Chisnall result_type a() const {return __p_.a();} 27157a984708SDavid Chisnall result_type b() const {return __p_.b();} 27167a984708SDavid Chisnall 27177a984708SDavid Chisnall param_type param() const {return __p_;} 27187a984708SDavid Chisnall void param(const param_type& __p) {__p_ = __p;} 27197a984708SDavid Chisnall 27207a984708SDavid Chisnall result_type min() const {return a();} 27217a984708SDavid Chisnall result_type max() const {return b();} 27227a984708SDavid Chisnall 27237a984708SDavid Chisnall friend bool operator==(const uniform_int_distribution& __x, 27247a984708SDavid Chisnall const uniform_int_distribution& __y) 27257a984708SDavid Chisnall {return __x.__p_ == __y.__p_;} 27267a984708SDavid Chisnall friend bool operator!=(const uniform_int_distribution& __x, 27277a984708SDavid Chisnall const uniform_int_distribution& __y) 27287a984708SDavid Chisnall {return !(__x == __y);} 27297a984708SDavid Chisnall}; 27307a984708SDavid Chisnall 27317a984708SDavid Chisnalltemplate<class _IntType> 27327a984708SDavid Chisnalltemplate<class _URNG> 27337a984708SDavid Chisnalltypename uniform_int_distribution<_IntType>::result_type 27347a984708SDavid Chisnalluniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) 27357a984708SDavid Chisnall{ 27367a984708SDavid Chisnall typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), 27377a984708SDavid Chisnall uint32_t, uint64_t>::type _UIntType; 273894e3ee44SDavid Chisnall const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1); 273994e3ee44SDavid Chisnall if (_Rp == 1) 27407a984708SDavid Chisnall return __p.a(); 27417a984708SDavid Chisnall const size_t _Dt = numeric_limits<_UIntType>::digits; 27427a984708SDavid Chisnall typedef __independent_bits_engine<_URNG, _UIntType> _Eng; 274394e3ee44SDavid Chisnall if (_Rp == 0) 27447a984708SDavid Chisnall return static_cast<result_type>(_Eng(__g, _Dt)()); 274594e3ee44SDavid Chisnall size_t __w = _Dt - __clz(_Rp) - 1; 274694e3ee44SDavid Chisnall if ((_Rp & (_UIntType(~0) >> (_Dt - __w))) != 0) 27477a984708SDavid Chisnall ++__w; 27487a984708SDavid Chisnall _Eng __e(__g, __w); 27497a984708SDavid Chisnall _UIntType __u; 27507a984708SDavid Chisnall do 27517a984708SDavid Chisnall { 27527a984708SDavid Chisnall __u = __e(); 275394e3ee44SDavid Chisnall } while (__u >= _Rp); 27547a984708SDavid Chisnall return static_cast<result_type>(__u + __p.a()); 27557a984708SDavid Chisnall} 27567a984708SDavid Chisnall 27577a984708SDavid Chisnallclass __rs_default; 27587a984708SDavid Chisnall 27597a984708SDavid Chisnall__rs_default __rs_get(); 27607a984708SDavid Chisnall 27617a984708SDavid Chisnallclass __rs_default 27627a984708SDavid Chisnall{ 27637a984708SDavid Chisnall static unsigned __c_; 27647a984708SDavid Chisnall 27657a984708SDavid Chisnall __rs_default(); 27667a984708SDavid Chisnallpublic: 27677a984708SDavid Chisnall typedef unsigned result_type; 27687a984708SDavid Chisnall 27697a984708SDavid Chisnall static const result_type _Min = 0; 27707a984708SDavid Chisnall static const result_type _Max = 0xFFFFFFFF; 27717a984708SDavid Chisnall 27727a984708SDavid Chisnall __rs_default(const __rs_default&); 27737a984708SDavid Chisnall ~__rs_default(); 27747a984708SDavid Chisnall 27757a984708SDavid Chisnall result_type operator()(); 27767a984708SDavid Chisnall 2777b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR result_type min() {return _Min;} 2778b03f91a8SDavid Chisnall static _LIBCPP_CONSTEXPR result_type max() {return _Max;} 27797a984708SDavid Chisnall 27807a984708SDavid Chisnall friend __rs_default __rs_get(); 27817a984708SDavid Chisnall}; 27827a984708SDavid Chisnall 27837a984708SDavid Chisnall__rs_default __rs_get(); 27847a984708SDavid Chisnall 27857a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 27867a984708SDavid Chisnallvoid 27877a984708SDavid Chisnallrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) 27887a984708SDavid Chisnall{ 27897a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 279094e3ee44SDavid Chisnall typedef uniform_int_distribution<ptrdiff_t> _Dp; 279194e3ee44SDavid Chisnall typedef typename _Dp::param_type _Pp; 27927a984708SDavid Chisnall difference_type __d = __last - __first; 27937a984708SDavid Chisnall if (__d > 1) 27947a984708SDavid Chisnall { 279594e3ee44SDavid Chisnall _Dp __uid; 27967a984708SDavid Chisnall __rs_default __g = __rs_get(); 27977a984708SDavid Chisnall for (--__last, --__d; __first < __last; ++__first, --__d) 27987a984708SDavid Chisnall { 279994e3ee44SDavid Chisnall difference_type __i = __uid(__g, _Pp(0, __d)); 28007a984708SDavid Chisnall if (__i != difference_type(0)) 28017a984708SDavid Chisnall swap(*__first, *(__first + __i)); 28027a984708SDavid Chisnall } 28037a984708SDavid Chisnall } 28047a984708SDavid Chisnall} 28057a984708SDavid Chisnall 28067a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _RandomNumberGenerator> 28077a984708SDavid Chisnallvoid 28087a984708SDavid Chisnallrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 28097a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 28107a984708SDavid Chisnall _RandomNumberGenerator&& __rand) 28117a984708SDavid Chisnall#else 28127a984708SDavid Chisnall _RandomNumberGenerator& __rand) 28137a984708SDavid Chisnall#endif 28147a984708SDavid Chisnall{ 28157a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 28167a984708SDavid Chisnall difference_type __d = __last - __first; 28177a984708SDavid Chisnall if (__d > 1) 28187a984708SDavid Chisnall { 28197a984708SDavid Chisnall for (--__last; __first < __last; ++__first, --__d) 28207a984708SDavid Chisnall { 28217a984708SDavid Chisnall difference_type __i = __rand(__d); 28227a984708SDavid Chisnall swap(*__first, *(__first + __i)); 28237a984708SDavid Chisnall } 28247a984708SDavid Chisnall } 28257a984708SDavid Chisnall} 28267a984708SDavid Chisnall 28277a984708SDavid Chisnalltemplate<class _RandomAccessIterator, class _UniformRandomNumberGenerator> 28287a984708SDavid Chisnall void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 28297a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 28307a984708SDavid Chisnall _UniformRandomNumberGenerator&& __g) 28317a984708SDavid Chisnall#else 28327a984708SDavid Chisnall _UniformRandomNumberGenerator& __g) 28337a984708SDavid Chisnall#endif 28347a984708SDavid Chisnall{ 28357a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 283694e3ee44SDavid Chisnall typedef uniform_int_distribution<ptrdiff_t> _Dp; 283794e3ee44SDavid Chisnall typedef typename _Dp::param_type _Pp; 28387a984708SDavid Chisnall difference_type __d = __last - __first; 28397a984708SDavid Chisnall if (__d > 1) 28407a984708SDavid Chisnall { 284194e3ee44SDavid Chisnall _Dp __uid; 28427a984708SDavid Chisnall for (--__last, --__d; __first < __last; ++__first, --__d) 28437a984708SDavid Chisnall { 284494e3ee44SDavid Chisnall difference_type __i = __uid(__g, _Pp(0, __d)); 28457a984708SDavid Chisnall if (__i != difference_type(0)) 28467a984708SDavid Chisnall swap(*__first, *(__first + __i)); 28477a984708SDavid Chisnall } 28487a984708SDavid Chisnall } 28497a984708SDavid Chisnall} 28507a984708SDavid Chisnall 28517a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate> 28527a984708SDavid Chisnallbool 28537a984708SDavid Chisnallis_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) 28547a984708SDavid Chisnall{ 28557a984708SDavid Chisnall for (; __first != __last; ++__first) 28567a984708SDavid Chisnall if (!__pred(*__first)) 28577a984708SDavid Chisnall break; 28587a984708SDavid Chisnall for (; __first != __last; ++__first) 28597a984708SDavid Chisnall if (__pred(*__first)) 28607a984708SDavid Chisnall return false; 28617a984708SDavid Chisnall return true; 28627a984708SDavid Chisnall} 28637a984708SDavid Chisnall 28647a984708SDavid Chisnall// partition 28657a984708SDavid Chisnall 28667a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator> 28677a984708SDavid Chisnall_ForwardIterator 28687a984708SDavid Chisnall__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) 28697a984708SDavid Chisnall{ 28707a984708SDavid Chisnall while (true) 28717a984708SDavid Chisnall { 28727a984708SDavid Chisnall if (__first == __last) 28737a984708SDavid Chisnall return __first; 28747a984708SDavid Chisnall if (!__pred(*__first)) 28757a984708SDavid Chisnall break; 28767a984708SDavid Chisnall ++__first; 28777a984708SDavid Chisnall } 28787a984708SDavid Chisnall for (_ForwardIterator __p = __first; ++__p != __last;) 28797a984708SDavid Chisnall { 28807a984708SDavid Chisnall if (__pred(*__p)) 28817a984708SDavid Chisnall { 28827a984708SDavid Chisnall swap(*__first, *__p); 28837a984708SDavid Chisnall ++__first; 28847a984708SDavid Chisnall } 28857a984708SDavid Chisnall } 28867a984708SDavid Chisnall return __first; 28877a984708SDavid Chisnall} 28887a984708SDavid Chisnall 28897a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator> 28907a984708SDavid Chisnall_BidirectionalIterator 28917a984708SDavid Chisnall__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 28927a984708SDavid Chisnall bidirectional_iterator_tag) 28937a984708SDavid Chisnall{ 28947a984708SDavid Chisnall while (true) 28957a984708SDavid Chisnall { 28967a984708SDavid Chisnall while (true) 28977a984708SDavid Chisnall { 28987a984708SDavid Chisnall if (__first == __last) 28997a984708SDavid Chisnall return __first; 29007a984708SDavid Chisnall if (!__pred(*__first)) 29017a984708SDavid Chisnall break; 29027a984708SDavid Chisnall ++__first; 29037a984708SDavid Chisnall } 29047a984708SDavid Chisnall do 29057a984708SDavid Chisnall { 29067a984708SDavid Chisnall if (__first == --__last) 29077a984708SDavid Chisnall return __first; 29087a984708SDavid Chisnall } while (!__pred(*__last)); 29097a984708SDavid Chisnall swap(*__first, *__last); 29107a984708SDavid Chisnall ++__first; 29117a984708SDavid Chisnall } 29127a984708SDavid Chisnall} 29137a984708SDavid Chisnall 29147a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate> 29157a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 29167a984708SDavid Chisnall_ForwardIterator 29177a984708SDavid Chisnallpartition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 29187a984708SDavid Chisnall{ 29197a984708SDavid Chisnall return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type> 29207a984708SDavid Chisnall (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 29217a984708SDavid Chisnall} 29227a984708SDavid Chisnall 29237a984708SDavid Chisnall// partition_copy 29247a984708SDavid Chisnall 29257a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator1, 29267a984708SDavid Chisnall class _OutputIterator2, class _Predicate> 29277a984708SDavid Chisnallpair<_OutputIterator1, _OutputIterator2> 29287a984708SDavid Chisnallpartition_copy(_InputIterator __first, _InputIterator __last, 29297a984708SDavid Chisnall _OutputIterator1 __out_true, _OutputIterator2 __out_false, 29307a984708SDavid Chisnall _Predicate __pred) 29317a984708SDavid Chisnall{ 29327a984708SDavid Chisnall for (; __first != __last; ++__first) 29337a984708SDavid Chisnall { 29347a984708SDavid Chisnall if (__pred(*__first)) 29357a984708SDavid Chisnall { 29367a984708SDavid Chisnall *__out_true = *__first; 29377a984708SDavid Chisnall ++__out_true; 29387a984708SDavid Chisnall } 29397a984708SDavid Chisnall else 29407a984708SDavid Chisnall { 29417a984708SDavid Chisnall *__out_false = *__first; 29427a984708SDavid Chisnall ++__out_false; 29437a984708SDavid Chisnall } 29447a984708SDavid Chisnall } 29457a984708SDavid Chisnall return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); 29467a984708SDavid Chisnall} 29477a984708SDavid Chisnall 29487a984708SDavid Chisnall// partition_point 29497a984708SDavid Chisnall 29507a984708SDavid Chisnalltemplate<class _ForwardIterator, class _Predicate> 29517a984708SDavid Chisnall_ForwardIterator 29527a984708SDavid Chisnallpartition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 29537a984708SDavid Chisnall{ 29547a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 29557a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 29567a984708SDavid Chisnall while (__len != 0) 29577a984708SDavid Chisnall { 29587a984708SDavid Chisnall difference_type __l2 = __len / 2; 29597a984708SDavid Chisnall _ForwardIterator __m = __first; 29607a984708SDavid Chisnall _VSTD::advance(__m, __l2); 29617a984708SDavid Chisnall if (__pred(*__m)) 29627a984708SDavid Chisnall { 29637a984708SDavid Chisnall __first = ++__m; 29647a984708SDavid Chisnall __len -= __l2 + 1; 29657a984708SDavid Chisnall } 29667a984708SDavid Chisnall else 29677a984708SDavid Chisnall __len = __l2; 29687a984708SDavid Chisnall } 29697a984708SDavid Chisnall return __first; 29707a984708SDavid Chisnall} 29717a984708SDavid Chisnall 29727a984708SDavid Chisnall// stable_partition 29737a984708SDavid Chisnall 29747a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator, class _Distance, class _Pair> 29757a984708SDavid Chisnall_ForwardIterator 29767a984708SDavid Chisnall__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 29777a984708SDavid Chisnall _Distance __len, _Pair __p, forward_iterator_tag __fit) 29787a984708SDavid Chisnall{ 29797a984708SDavid Chisnall // *__first is known to be false 29807a984708SDavid Chisnall // __len >= 1 29817a984708SDavid Chisnall if (__len == 1) 29827a984708SDavid Chisnall return __first; 29837a984708SDavid Chisnall if (__len == 2) 29847a984708SDavid Chisnall { 29857a984708SDavid Chisnall _ForwardIterator __m = __first; 29867a984708SDavid Chisnall if (__pred(*++__m)) 29877a984708SDavid Chisnall { 29887a984708SDavid Chisnall swap(*__first, *__m); 29897a984708SDavid Chisnall return __m; 29907a984708SDavid Chisnall } 29917a984708SDavid Chisnall return __first; 29927a984708SDavid Chisnall } 29937a984708SDavid Chisnall if (__len <= __p.second) 29947a984708SDavid Chisnall { // The buffer is big enough to use 29957a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 29967a984708SDavid Chisnall __destruct_n __d(0); 29977a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 29987a984708SDavid Chisnall // Move the falses into the temporary buffer, and the trues to the front of the line 29997a984708SDavid Chisnall // Update __first to always point to the end of the trues 30007a984708SDavid Chisnall value_type* __t = __p.first; 30017a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__first)); 30027a984708SDavid Chisnall __d.__incr((value_type*)0); 30037a984708SDavid Chisnall ++__t; 30047a984708SDavid Chisnall _ForwardIterator __i = __first; 30057a984708SDavid Chisnall while (++__i != __last) 30067a984708SDavid Chisnall { 30077a984708SDavid Chisnall if (__pred(*__i)) 30087a984708SDavid Chisnall { 30097a984708SDavid Chisnall *__first = _VSTD::move(*__i); 30107a984708SDavid Chisnall ++__first; 30117a984708SDavid Chisnall } 30127a984708SDavid Chisnall else 30137a984708SDavid Chisnall { 30147a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__i)); 30157a984708SDavid Chisnall __d.__incr((value_type*)0); 30167a984708SDavid Chisnall ++__t; 30177a984708SDavid Chisnall } 30187a984708SDavid Chisnall } 30197a984708SDavid Chisnall // All trues now at start of range, all falses in buffer 30207a984708SDavid Chisnall // Move falses back into range, but don't mess up __first which points to first false 30217a984708SDavid Chisnall __i = __first; 30227a984708SDavid Chisnall for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 30237a984708SDavid Chisnall *__i = _VSTD::move(*__t2); 30247a984708SDavid Chisnall // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 30257a984708SDavid Chisnall return __first; 30267a984708SDavid Chisnall } 30277a984708SDavid Chisnall // Else not enough buffer, do in place 30287a984708SDavid Chisnall // __len >= 3 30297a984708SDavid Chisnall _ForwardIterator __m = __first; 30307a984708SDavid Chisnall _Distance __len2 = __len / 2; // __len2 >= 2 30317a984708SDavid Chisnall _VSTD::advance(__m, __len2); 30327a984708SDavid Chisnall // recurse on [__first, __m), *__first know to be false 30337a984708SDavid Chisnall // F????????????????? 30347a984708SDavid Chisnall // f m l 30357a984708SDavid Chisnall typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 30367a984708SDavid Chisnall _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit); 30377a984708SDavid Chisnall // TTTFFFFF?????????? 30387a984708SDavid Chisnall // f ff m l 30397a984708SDavid Chisnall // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 30407a984708SDavid Chisnall _ForwardIterator __m1 = __m; 30417a984708SDavid Chisnall _ForwardIterator __second_false = __last; 30427a984708SDavid Chisnall _Distance __len_half = __len - __len2; 30437a984708SDavid Chisnall while (__pred(*__m1)) 30447a984708SDavid Chisnall { 30457a984708SDavid Chisnall if (++__m1 == __last) 30467a984708SDavid Chisnall goto __second_half_done; 30477a984708SDavid Chisnall --__len_half; 30487a984708SDavid Chisnall } 30497a984708SDavid Chisnall // TTTFFFFFTTTF?????? 30507a984708SDavid Chisnall // f ff m m1 l 30517a984708SDavid Chisnall __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit); 30527a984708SDavid Chisnall__second_half_done: 30537a984708SDavid Chisnall // TTTFFFFFTTTTTFFFFF 30547a984708SDavid Chisnall // f ff m sf l 30557a984708SDavid Chisnall return _VSTD::rotate(__first_false, __m, __second_false); 30567a984708SDavid Chisnall // TTTTTTTTFFFFFFFFFF 30577a984708SDavid Chisnall // | 30587a984708SDavid Chisnall} 30597a984708SDavid Chisnall 30607a984708SDavid Chisnallstruct __return_temporary_buffer 30617a984708SDavid Chisnall{ 30627a984708SDavid Chisnall template <class _Tp> 30637a984708SDavid Chisnall _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);} 30647a984708SDavid Chisnall}; 30657a984708SDavid Chisnall 30667a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator> 30677a984708SDavid Chisnall_ForwardIterator 30687a984708SDavid Chisnall__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 30697a984708SDavid Chisnall forward_iterator_tag) 30707a984708SDavid Chisnall{ 30717a984708SDavid Chisnall const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment 30727a984708SDavid Chisnall // Either prove all true and return __first or point to first false 30737a984708SDavid Chisnall while (true) 30747a984708SDavid Chisnall { 30757a984708SDavid Chisnall if (__first == __last) 30767a984708SDavid Chisnall return __first; 30777a984708SDavid Chisnall if (!__pred(*__first)) 30787a984708SDavid Chisnall break; 30797a984708SDavid Chisnall ++__first; 30807a984708SDavid Chisnall } 30817a984708SDavid Chisnall // We now have a reduced range [__first, __last) 30827a984708SDavid Chisnall // *__first is known to be false 30837a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 30847a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 30857a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 30867a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __p(0, 0); 30877a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 30887a984708SDavid Chisnall if (__len >= __alloc_limit) 30897a984708SDavid Chisnall { 30907a984708SDavid Chisnall __p = _VSTD::get_temporary_buffer<value_type>(__len); 30917a984708SDavid Chisnall __h.reset(__p.first); 30927a984708SDavid Chisnall } 30937a984708SDavid Chisnall return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 30947a984708SDavid Chisnall (__first, __last, __pred, __len, __p, forward_iterator_tag()); 30957a984708SDavid Chisnall} 30967a984708SDavid Chisnall 30977a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair> 30987a984708SDavid Chisnall_BidirectionalIterator 30997a984708SDavid Chisnall__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 31007a984708SDavid Chisnall _Distance __len, _Pair __p, bidirectional_iterator_tag __bit) 31017a984708SDavid Chisnall{ 31027a984708SDavid Chisnall // *__first is known to be false 31037a984708SDavid Chisnall // *__last is known to be true 31047a984708SDavid Chisnall // __len >= 2 31057a984708SDavid Chisnall if (__len == 2) 31067a984708SDavid Chisnall { 31077a984708SDavid Chisnall swap(*__first, *__last); 31087a984708SDavid Chisnall return __last; 31097a984708SDavid Chisnall } 31107a984708SDavid Chisnall if (__len == 3) 31117a984708SDavid Chisnall { 31127a984708SDavid Chisnall _BidirectionalIterator __m = __first; 31137a984708SDavid Chisnall if (__pred(*++__m)) 31147a984708SDavid Chisnall { 31157a984708SDavid Chisnall swap(*__first, *__m); 31167a984708SDavid Chisnall swap(*__m, *__last); 31177a984708SDavid Chisnall return __last; 31187a984708SDavid Chisnall } 31197a984708SDavid Chisnall swap(*__m, *__last); 31207a984708SDavid Chisnall swap(*__first, *__m); 31217a984708SDavid Chisnall return __m; 31227a984708SDavid Chisnall } 31237a984708SDavid Chisnall if (__len <= __p.second) 31247a984708SDavid Chisnall { // The buffer is big enough to use 31257a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 31267a984708SDavid Chisnall __destruct_n __d(0); 31277a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 31287a984708SDavid Chisnall // Move the falses into the temporary buffer, and the trues to the front of the line 31297a984708SDavid Chisnall // Update __first to always point to the end of the trues 31307a984708SDavid Chisnall value_type* __t = __p.first; 31317a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__first)); 31327a984708SDavid Chisnall __d.__incr((value_type*)0); 31337a984708SDavid Chisnall ++__t; 31347a984708SDavid Chisnall _BidirectionalIterator __i = __first; 31357a984708SDavid Chisnall while (++__i != __last) 31367a984708SDavid Chisnall { 31377a984708SDavid Chisnall if (__pred(*__i)) 31387a984708SDavid Chisnall { 31397a984708SDavid Chisnall *__first = _VSTD::move(*__i); 31407a984708SDavid Chisnall ++__first; 31417a984708SDavid Chisnall } 31427a984708SDavid Chisnall else 31437a984708SDavid Chisnall { 31447a984708SDavid Chisnall ::new(__t) value_type(_VSTD::move(*__i)); 31457a984708SDavid Chisnall __d.__incr((value_type*)0); 31467a984708SDavid Chisnall ++__t; 31477a984708SDavid Chisnall } 31487a984708SDavid Chisnall } 31497a984708SDavid Chisnall // move *__last, known to be true 31507a984708SDavid Chisnall *__first = _VSTD::move(*__i); 31517a984708SDavid Chisnall __i = ++__first; 31527a984708SDavid Chisnall // All trues now at start of range, all falses in buffer 31537a984708SDavid Chisnall // Move falses back into range, but don't mess up __first which points to first false 31547a984708SDavid Chisnall for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 31557a984708SDavid Chisnall *__i = _VSTD::move(*__t2); 31567a984708SDavid Chisnall // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 31577a984708SDavid Chisnall return __first; 31587a984708SDavid Chisnall } 31597a984708SDavid Chisnall // Else not enough buffer, do in place 31607a984708SDavid Chisnall // __len >= 4 31617a984708SDavid Chisnall _BidirectionalIterator __m = __first; 31627a984708SDavid Chisnall _Distance __len2 = __len / 2; // __len2 >= 2 31637a984708SDavid Chisnall _VSTD::advance(__m, __len2); 31647a984708SDavid Chisnall // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false 31657a984708SDavid Chisnall // F????????????????T 31667a984708SDavid Chisnall // f m l 31677a984708SDavid Chisnall _BidirectionalIterator __m1 = __m; 31687a984708SDavid Chisnall _BidirectionalIterator __first_false = __first; 31697a984708SDavid Chisnall _Distance __len_half = __len2; 31707a984708SDavid Chisnall while (!__pred(*--__m1)) 31717a984708SDavid Chisnall { 31727a984708SDavid Chisnall if (__m1 == __first) 31737a984708SDavid Chisnall goto __first_half_done; 31747a984708SDavid Chisnall --__len_half; 31757a984708SDavid Chisnall } 31767a984708SDavid Chisnall // F???TFFF?????????T 31777a984708SDavid Chisnall // f m1 m l 31787a984708SDavid Chisnall typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 31797a984708SDavid Chisnall __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit); 31807a984708SDavid Chisnall__first_half_done: 31817a984708SDavid Chisnall // TTTFFFFF?????????T 31827a984708SDavid Chisnall // f ff m l 31837a984708SDavid Chisnall // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 31847a984708SDavid Chisnall __m1 = __m; 31857a984708SDavid Chisnall _BidirectionalIterator __second_false = __last; 31867a984708SDavid Chisnall ++__second_false; 31877a984708SDavid Chisnall __len_half = __len - __len2; 31887a984708SDavid Chisnall while (__pred(*__m1)) 31897a984708SDavid Chisnall { 31907a984708SDavid Chisnall if (++__m1 == __last) 31917a984708SDavid Chisnall goto __second_half_done; 31927a984708SDavid Chisnall --__len_half; 31937a984708SDavid Chisnall } 31947a984708SDavid Chisnall // TTTFFFFFTTTF?????T 31957a984708SDavid Chisnall // f ff m m1 l 31967a984708SDavid Chisnall __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit); 31977a984708SDavid Chisnall__second_half_done: 31987a984708SDavid Chisnall // TTTFFFFFTTTTTFFFFF 31997a984708SDavid Chisnall // f ff m sf l 32007a984708SDavid Chisnall return _VSTD::rotate(__first_false, __m, __second_false); 32017a984708SDavid Chisnall // TTTTTTTTFFFFFFFFFF 32027a984708SDavid Chisnall // | 32037a984708SDavid Chisnall} 32047a984708SDavid Chisnall 32057a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator> 32067a984708SDavid Chisnall_BidirectionalIterator 32077a984708SDavid Chisnall__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 32087a984708SDavid Chisnall bidirectional_iterator_tag) 32097a984708SDavid Chisnall{ 32107a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 32117a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 32127a984708SDavid Chisnall const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment 32137a984708SDavid Chisnall // Either prove all true and return __first or point to first false 32147a984708SDavid Chisnall while (true) 32157a984708SDavid Chisnall { 32167a984708SDavid Chisnall if (__first == __last) 32177a984708SDavid Chisnall return __first; 32187a984708SDavid Chisnall if (!__pred(*__first)) 32197a984708SDavid Chisnall break; 32207a984708SDavid Chisnall ++__first; 32217a984708SDavid Chisnall } 32227a984708SDavid Chisnall // __first points to first false, everything prior to __first is already set. 32237a984708SDavid Chisnall // Either prove [__first, __last) is all false and return __first, or point __last to last true 32247a984708SDavid Chisnall do 32257a984708SDavid Chisnall { 32267a984708SDavid Chisnall if (__first == --__last) 32277a984708SDavid Chisnall return __first; 32287a984708SDavid Chisnall } while (!__pred(*__last)); 32297a984708SDavid Chisnall // We now have a reduced range [__first, __last] 32307a984708SDavid Chisnall // *__first is known to be false 32317a984708SDavid Chisnall // *__last is known to be true 32327a984708SDavid Chisnall // __len >= 2 32337a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last) + 1; 32347a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __p(0, 0); 32357a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 32367a984708SDavid Chisnall if (__len >= __alloc_limit) 32377a984708SDavid Chisnall { 32387a984708SDavid Chisnall __p = _VSTD::get_temporary_buffer<value_type>(__len); 32397a984708SDavid Chisnall __h.reset(__p.first); 32407a984708SDavid Chisnall } 32417a984708SDavid Chisnall return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 32427a984708SDavid Chisnall (__first, __last, __pred, __len, __p, bidirectional_iterator_tag()); 32437a984708SDavid Chisnall} 32447a984708SDavid Chisnall 32457a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate> 32467a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 32477a984708SDavid Chisnall_ForwardIterator 32487a984708SDavid Chisnallstable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 32497a984708SDavid Chisnall{ 32507a984708SDavid Chisnall return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 32517a984708SDavid Chisnall (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 32527a984708SDavid Chisnall} 32537a984708SDavid Chisnall 32547a984708SDavid Chisnall// is_sorted_until 32557a984708SDavid Chisnall 32567a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 32577a984708SDavid Chisnall_ForwardIterator 32587a984708SDavid Chisnallis_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 32597a984708SDavid Chisnall{ 32607a984708SDavid Chisnall if (__first != __last) 32617a984708SDavid Chisnall { 32627a984708SDavid Chisnall _ForwardIterator __i = __first; 32637a984708SDavid Chisnall while (++__i != __last) 32647a984708SDavid Chisnall { 32657a984708SDavid Chisnall if (__comp(*__i, *__first)) 32667a984708SDavid Chisnall return __i; 32677a984708SDavid Chisnall __first = __i; 32687a984708SDavid Chisnall } 32697a984708SDavid Chisnall } 32707a984708SDavid Chisnall return __last; 32717a984708SDavid Chisnall} 32727a984708SDavid Chisnall 32737a984708SDavid Chisnalltemplate<class _ForwardIterator> 32747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 32757a984708SDavid Chisnall_ForwardIterator 32767a984708SDavid Chisnallis_sorted_until(_ForwardIterator __first, _ForwardIterator __last) 32777a984708SDavid Chisnall{ 32787a984708SDavid Chisnall return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 32797a984708SDavid Chisnall} 32807a984708SDavid Chisnall 32817a984708SDavid Chisnall// is_sorted 32827a984708SDavid Chisnall 32837a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare> 32847a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 32857a984708SDavid Chisnallbool 32867a984708SDavid Chisnallis_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 32877a984708SDavid Chisnall{ 32887a984708SDavid Chisnall return _VSTD::is_sorted_until(__first, __last, __comp) == __last; 32897a984708SDavid Chisnall} 32907a984708SDavid Chisnall 32917a984708SDavid Chisnalltemplate<class _ForwardIterator> 32927a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 32937a984708SDavid Chisnallbool 32947a984708SDavid Chisnallis_sorted(_ForwardIterator __first, _ForwardIterator __last) 32957a984708SDavid Chisnall{ 32967a984708SDavid Chisnall return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 32977a984708SDavid Chisnall} 32987a984708SDavid Chisnall 32997a984708SDavid Chisnall// sort 33007a984708SDavid Chisnall 33017a984708SDavid Chisnall// stable, 2-3 compares, 0-2 swaps 33027a984708SDavid Chisnall 33037a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator> 33047a984708SDavid Chisnallunsigned 33057a984708SDavid Chisnall__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c) 33067a984708SDavid Chisnall{ 33077a984708SDavid Chisnall unsigned __r = 0; 33087a984708SDavid Chisnall if (!__c(*__y, *__x)) // if x <= y 33097a984708SDavid Chisnall { 33107a984708SDavid Chisnall if (!__c(*__z, *__y)) // if y <= z 33117a984708SDavid Chisnall return __r; // x <= y && y <= z 33127a984708SDavid Chisnall // x <= y && y > z 33137a984708SDavid Chisnall swap(*__y, *__z); // x <= z && y < z 33147a984708SDavid Chisnall __r = 1; 33157a984708SDavid Chisnall if (__c(*__y, *__x)) // if x > y 33167a984708SDavid Chisnall { 33177a984708SDavid Chisnall swap(*__x, *__y); // x < y && y <= z 33187a984708SDavid Chisnall __r = 2; 33197a984708SDavid Chisnall } 33207a984708SDavid Chisnall return __r; // x <= y && y < z 33217a984708SDavid Chisnall } 33227a984708SDavid Chisnall if (__c(*__z, *__y)) // x > y, if y > z 33237a984708SDavid Chisnall { 33247a984708SDavid Chisnall swap(*__x, *__z); // x < y && y < z 33257a984708SDavid Chisnall __r = 1; 33267a984708SDavid Chisnall return __r; 33277a984708SDavid Chisnall } 33287a984708SDavid Chisnall swap(*__x, *__y); // x > y && y <= z 33297a984708SDavid Chisnall __r = 1; // x < y && x <= z 33307a984708SDavid Chisnall if (__c(*__z, *__y)) // if y > z 33317a984708SDavid Chisnall { 33327a984708SDavid Chisnall swap(*__y, *__z); // x <= y && y < z 33337a984708SDavid Chisnall __r = 2; 33347a984708SDavid Chisnall } 33357a984708SDavid Chisnall return __r; 33367a984708SDavid Chisnall} // x <= y && y <= z 33377a984708SDavid Chisnall 33387a984708SDavid Chisnall// stable, 3-6 compares, 0-5 swaps 33397a984708SDavid Chisnall 33407a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator> 33417a984708SDavid Chisnallunsigned 33427a984708SDavid Chisnall__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 33437a984708SDavid Chisnall _ForwardIterator __x4, _Compare __c) 33447a984708SDavid Chisnall{ 33457a984708SDavid Chisnall unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c); 33467a984708SDavid Chisnall if (__c(*__x4, *__x3)) 33477a984708SDavid Chisnall { 33487a984708SDavid Chisnall swap(*__x3, *__x4); 33497a984708SDavid Chisnall ++__r; 33507a984708SDavid Chisnall if (__c(*__x3, *__x2)) 33517a984708SDavid Chisnall { 33527a984708SDavid Chisnall swap(*__x2, *__x3); 33537a984708SDavid Chisnall ++__r; 33547a984708SDavid Chisnall if (__c(*__x2, *__x1)) 33557a984708SDavid Chisnall { 33567a984708SDavid Chisnall swap(*__x1, *__x2); 33577a984708SDavid Chisnall ++__r; 33587a984708SDavid Chisnall } 33597a984708SDavid Chisnall } 33607a984708SDavid Chisnall } 33617a984708SDavid Chisnall return __r; 33627a984708SDavid Chisnall} 33637a984708SDavid Chisnall 33647a984708SDavid Chisnall// stable, 4-10 compares, 0-9 swaps 33657a984708SDavid Chisnall 33667a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator> 33677a984708SDavid Chisnallunsigned 33687a984708SDavid Chisnall__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 33697a984708SDavid Chisnall _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c) 33707a984708SDavid Chisnall{ 33717a984708SDavid Chisnall unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c); 33727a984708SDavid Chisnall if (__c(*__x5, *__x4)) 33737a984708SDavid Chisnall { 33747a984708SDavid Chisnall swap(*__x4, *__x5); 33757a984708SDavid Chisnall ++__r; 33767a984708SDavid Chisnall if (__c(*__x4, *__x3)) 33777a984708SDavid Chisnall { 33787a984708SDavid Chisnall swap(*__x3, *__x4); 33797a984708SDavid Chisnall ++__r; 33807a984708SDavid Chisnall if (__c(*__x3, *__x2)) 33817a984708SDavid Chisnall { 33827a984708SDavid Chisnall swap(*__x2, *__x3); 33837a984708SDavid Chisnall ++__r; 33847a984708SDavid Chisnall if (__c(*__x2, *__x1)) 33857a984708SDavid Chisnall { 33867a984708SDavid Chisnall swap(*__x1, *__x2); 33877a984708SDavid Chisnall ++__r; 33887a984708SDavid Chisnall } 33897a984708SDavid Chisnall } 33907a984708SDavid Chisnall } 33917a984708SDavid Chisnall } 33927a984708SDavid Chisnall return __r; 33937a984708SDavid Chisnall} 33947a984708SDavid Chisnall 33957a984708SDavid Chisnall// Assumes size > 0 33967a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator> 33977a984708SDavid Chisnallvoid 33987a984708SDavid Chisnall__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 33997a984708SDavid Chisnall{ 34007a984708SDavid Chisnall _BirdirectionalIterator __lm1 = __last; 34017a984708SDavid Chisnall for (--__lm1; __first != __lm1; ++__first) 34027a984708SDavid Chisnall { 34037a984708SDavid Chisnall _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator, 34047a984708SDavid Chisnall typename add_lvalue_reference<_Compare>::type> 34057a984708SDavid Chisnall (__first, __last, __comp); 34067a984708SDavid Chisnall if (__i != __first) 34077a984708SDavid Chisnall swap(*__first, *__i); 34087a984708SDavid Chisnall } 34097a984708SDavid Chisnall} 34107a984708SDavid Chisnall 34117a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator> 34127a984708SDavid Chisnallvoid 34137a984708SDavid Chisnall__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 34147a984708SDavid Chisnall{ 34157a984708SDavid Chisnall typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 34167a984708SDavid Chisnall if (__first != __last) 34177a984708SDavid Chisnall { 34187a984708SDavid Chisnall _BirdirectionalIterator __i = __first; 34197a984708SDavid Chisnall for (++__i; __i != __last; ++__i) 34207a984708SDavid Chisnall { 34217a984708SDavid Chisnall _BirdirectionalIterator __j = __i; 34227a984708SDavid Chisnall value_type __t(_VSTD::move(*__j)); 34237a984708SDavid Chisnall for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j) 34247a984708SDavid Chisnall *__j = _VSTD::move(*__k); 34257a984708SDavid Chisnall *__j = _VSTD::move(__t); 34267a984708SDavid Chisnall } 34277a984708SDavid Chisnall } 34287a984708SDavid Chisnall} 34297a984708SDavid Chisnall 34307a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 34317a984708SDavid Chisnallvoid 34327a984708SDavid Chisnall__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 34337a984708SDavid Chisnall{ 34347a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 34357a984708SDavid Chisnall _RandomAccessIterator __j = __first+2; 34367a984708SDavid Chisnall __sort3<_Compare>(__first, __first+1, __j, __comp); 34377a984708SDavid Chisnall for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 34387a984708SDavid Chisnall { 34397a984708SDavid Chisnall if (__comp(*__i, *__j)) 34407a984708SDavid Chisnall { 34417a984708SDavid Chisnall value_type __t(_VSTD::move(*__i)); 34427a984708SDavid Chisnall _RandomAccessIterator __k = __j; 34437a984708SDavid Chisnall __j = __i; 34447a984708SDavid Chisnall do 34457a984708SDavid Chisnall { 34467a984708SDavid Chisnall *__j = _VSTD::move(*__k); 34477a984708SDavid Chisnall __j = __k; 34487a984708SDavid Chisnall } while (__j != __first && __comp(__t, *--__k)); 34497a984708SDavid Chisnall *__j = _VSTD::move(__t); 34507a984708SDavid Chisnall } 34517a984708SDavid Chisnall __j = __i; 34527a984708SDavid Chisnall } 34537a984708SDavid Chisnall} 34547a984708SDavid Chisnall 34557a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 34567a984708SDavid Chisnallbool 34577a984708SDavid Chisnall__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 34587a984708SDavid Chisnall{ 34597a984708SDavid Chisnall switch (__last - __first) 34607a984708SDavid Chisnall { 34617a984708SDavid Chisnall case 0: 34627a984708SDavid Chisnall case 1: 34637a984708SDavid Chisnall return true; 34647a984708SDavid Chisnall case 2: 34657a984708SDavid Chisnall if (__comp(*--__last, *__first)) 34667a984708SDavid Chisnall swap(*__first, *__last); 34677a984708SDavid Chisnall return true; 34687a984708SDavid Chisnall case 3: 34697a984708SDavid Chisnall _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 34707a984708SDavid Chisnall return true; 34717a984708SDavid Chisnall case 4: 34727a984708SDavid Chisnall _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 34737a984708SDavid Chisnall return true; 34747a984708SDavid Chisnall case 5: 34757a984708SDavid Chisnall _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 34767a984708SDavid Chisnall return true; 34777a984708SDavid Chisnall } 34787a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 34797a984708SDavid Chisnall _RandomAccessIterator __j = __first+2; 34807a984708SDavid Chisnall __sort3<_Compare>(__first, __first+1, __j, __comp); 34817a984708SDavid Chisnall const unsigned __limit = 8; 34827a984708SDavid Chisnall unsigned __count = 0; 34837a984708SDavid Chisnall for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 34847a984708SDavid Chisnall { 34857a984708SDavid Chisnall if (__comp(*__i, *__j)) 34867a984708SDavid Chisnall { 34877a984708SDavid Chisnall value_type __t(_VSTD::move(*__i)); 34887a984708SDavid Chisnall _RandomAccessIterator __k = __j; 34897a984708SDavid Chisnall __j = __i; 34907a984708SDavid Chisnall do 34917a984708SDavid Chisnall { 34927a984708SDavid Chisnall *__j = _VSTD::move(*__k); 34937a984708SDavid Chisnall __j = __k; 34947a984708SDavid Chisnall } while (__j != __first && __comp(__t, *--__k)); 34957a984708SDavid Chisnall *__j = _VSTD::move(__t); 34967a984708SDavid Chisnall if (++__count == __limit) 34977a984708SDavid Chisnall return ++__i == __last; 34987a984708SDavid Chisnall } 34997a984708SDavid Chisnall __j = __i; 35007a984708SDavid Chisnall } 35017a984708SDavid Chisnall return true; 35027a984708SDavid Chisnall} 35037a984708SDavid Chisnall 35047a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator> 35057a984708SDavid Chisnallvoid 35067a984708SDavid Chisnall__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1, 35077a984708SDavid Chisnall typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp) 35087a984708SDavid Chisnall{ 35097a984708SDavid Chisnall typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 35107a984708SDavid Chisnall if (__first1 != __last1) 35117a984708SDavid Chisnall { 35127a984708SDavid Chisnall __destruct_n __d(0); 35137a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__first2, __d); 35147a984708SDavid Chisnall value_type* __last2 = __first2; 35157a984708SDavid Chisnall ::new(__last2) value_type(_VSTD::move(*__first1)); 35167a984708SDavid Chisnall __d.__incr((value_type*)0); 35177a984708SDavid Chisnall for (++__last2; ++__first1 != __last1; ++__last2) 35187a984708SDavid Chisnall { 35197a984708SDavid Chisnall value_type* __j2 = __last2; 35207a984708SDavid Chisnall value_type* __i2 = __j2; 35217a984708SDavid Chisnall if (__comp(*__first1, *--__i2)) 35227a984708SDavid Chisnall { 35237a984708SDavid Chisnall ::new(__j2) value_type(_VSTD::move(*__i2)); 35247a984708SDavid Chisnall __d.__incr((value_type*)0); 35257a984708SDavid Chisnall for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2) 35267a984708SDavid Chisnall *__j2 = _VSTD::move(*__i2); 35277a984708SDavid Chisnall *__j2 = _VSTD::move(*__first1); 35287a984708SDavid Chisnall } 35297a984708SDavid Chisnall else 35307a984708SDavid Chisnall { 35317a984708SDavid Chisnall ::new(__j2) value_type(_VSTD::move(*__first1)); 35327a984708SDavid Chisnall __d.__incr((value_type*)0); 35337a984708SDavid Chisnall } 35347a984708SDavid Chisnall } 35357a984708SDavid Chisnall __h.release(); 35367a984708SDavid Chisnall } 35377a984708SDavid Chisnall} 35387a984708SDavid Chisnall 35397a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 35407a984708SDavid Chisnallvoid 35417a984708SDavid Chisnall__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 35427a984708SDavid Chisnall{ 35437a984708SDavid Chisnall // _Compare is known to be a reference type 35447a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 35457a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 35467a984708SDavid Chisnall const difference_type __limit = is_trivially_copy_constructible<value_type>::value && 35477a984708SDavid Chisnall is_trivially_copy_assignable<value_type>::value ? 30 : 6; 35487a984708SDavid Chisnall while (true) 35497a984708SDavid Chisnall { 35507a984708SDavid Chisnall __restart: 35517a984708SDavid Chisnall difference_type __len = __last - __first; 35527a984708SDavid Chisnall switch (__len) 35537a984708SDavid Chisnall { 35547a984708SDavid Chisnall case 0: 35557a984708SDavid Chisnall case 1: 35567a984708SDavid Chisnall return; 35577a984708SDavid Chisnall case 2: 35587a984708SDavid Chisnall if (__comp(*--__last, *__first)) 35597a984708SDavid Chisnall swap(*__first, *__last); 35607a984708SDavid Chisnall return; 35617a984708SDavid Chisnall case 3: 35627a984708SDavid Chisnall _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 35637a984708SDavid Chisnall return; 35647a984708SDavid Chisnall case 4: 35657a984708SDavid Chisnall _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 35667a984708SDavid Chisnall return; 35677a984708SDavid Chisnall case 5: 35687a984708SDavid Chisnall _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 35697a984708SDavid Chisnall return; 35707a984708SDavid Chisnall } 35717a984708SDavid Chisnall if (__len <= __limit) 35727a984708SDavid Chisnall { 35737a984708SDavid Chisnall _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp); 35747a984708SDavid Chisnall return; 35757a984708SDavid Chisnall } 35767a984708SDavid Chisnall // __len > 5 35777a984708SDavid Chisnall _RandomAccessIterator __m = __first; 35787a984708SDavid Chisnall _RandomAccessIterator __lm1 = __last; 35797a984708SDavid Chisnall --__lm1; 35807a984708SDavid Chisnall unsigned __n_swaps; 35817a984708SDavid Chisnall { 35827a984708SDavid Chisnall difference_type __delta; 35837a984708SDavid Chisnall if (__len >= 1000) 35847a984708SDavid Chisnall { 35857a984708SDavid Chisnall __delta = __len/2; 35867a984708SDavid Chisnall __m += __delta; 35877a984708SDavid Chisnall __delta /= 2; 35887a984708SDavid Chisnall __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp); 35897a984708SDavid Chisnall } 35907a984708SDavid Chisnall else 35917a984708SDavid Chisnall { 35927a984708SDavid Chisnall __delta = __len/2; 35937a984708SDavid Chisnall __m += __delta; 35947a984708SDavid Chisnall __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp); 35957a984708SDavid Chisnall } 35967a984708SDavid Chisnall } 35977a984708SDavid Chisnall // *__m is median 35987a984708SDavid Chisnall // partition [__first, __m) < *__m and *__m <= [__m, __last) 35997a984708SDavid Chisnall // (this inhibits tossing elements equivalent to __m around unnecessarily) 36007a984708SDavid Chisnall _RandomAccessIterator __i = __first; 36017a984708SDavid Chisnall _RandomAccessIterator __j = __lm1; 36027a984708SDavid Chisnall // j points beyond range to be tested, *__m is known to be <= *__lm1 36037a984708SDavid Chisnall // The search going up is known to be guarded but the search coming down isn't. 36047a984708SDavid Chisnall // Prime the downward search with a guard. 36057a984708SDavid Chisnall if (!__comp(*__i, *__m)) // if *__first == *__m 36067a984708SDavid Chisnall { 36077a984708SDavid Chisnall // *__first == *__m, *__first doesn't go in first part 36087a984708SDavid Chisnall // manually guard downward moving __j against __i 36097a984708SDavid Chisnall while (true) 36107a984708SDavid Chisnall { 36117a984708SDavid Chisnall if (__i == --__j) 36127a984708SDavid Chisnall { 36137a984708SDavid Chisnall // *__first == *__m, *__m <= all other elements 36147a984708SDavid Chisnall // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 36157a984708SDavid Chisnall ++__i; // __first + 1 36167a984708SDavid Chisnall __j = __last; 36177a984708SDavid Chisnall if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 36187a984708SDavid Chisnall { 36197a984708SDavid Chisnall while (true) 36207a984708SDavid Chisnall { 36217a984708SDavid Chisnall if (__i == __j) 36227a984708SDavid Chisnall return; // [__first, __last) all equivalent elements 36237a984708SDavid Chisnall if (__comp(*__first, *__i)) 36247a984708SDavid Chisnall { 36257a984708SDavid Chisnall swap(*__i, *__j); 36267a984708SDavid Chisnall ++__n_swaps; 36277a984708SDavid Chisnall ++__i; 36287a984708SDavid Chisnall break; 36297a984708SDavid Chisnall } 36307a984708SDavid Chisnall ++__i; 36317a984708SDavid Chisnall } 36327a984708SDavid Chisnall } 36337a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 36347a984708SDavid Chisnall if (__i == __j) 36357a984708SDavid Chisnall return; 36367a984708SDavid Chisnall while (true) 36377a984708SDavid Chisnall { 36387a984708SDavid Chisnall while (!__comp(*__first, *__i)) 36397a984708SDavid Chisnall ++__i; 36407a984708SDavid Chisnall while (__comp(*__first, *--__j)) 36417a984708SDavid Chisnall ; 36427a984708SDavid Chisnall if (__i >= __j) 36437a984708SDavid Chisnall break; 36447a984708SDavid Chisnall swap(*__i, *__j); 36457a984708SDavid Chisnall ++__n_swaps; 36467a984708SDavid Chisnall ++__i; 36477a984708SDavid Chisnall } 36487a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__i, __last) 36497a984708SDavid Chisnall // The first part is sorted, sort the secod part 36507a984708SDavid Chisnall // _VSTD::__sort<_Compare>(__i, __last, __comp); 36517a984708SDavid Chisnall __first = __i; 36527a984708SDavid Chisnall goto __restart; 36537a984708SDavid Chisnall } 36547a984708SDavid Chisnall if (__comp(*__j, *__m)) 36557a984708SDavid Chisnall { 36567a984708SDavid Chisnall swap(*__i, *__j); 36577a984708SDavid Chisnall ++__n_swaps; 36587a984708SDavid Chisnall break; // found guard for downward moving __j, now use unguarded partition 36597a984708SDavid Chisnall } 36607a984708SDavid Chisnall } 36617a984708SDavid Chisnall } 36627a984708SDavid Chisnall // It is known that *__i < *__m 36637a984708SDavid Chisnall ++__i; 36647a984708SDavid Chisnall // j points beyond range to be tested, *__m is known to be <= *__lm1 36657a984708SDavid Chisnall // if not yet partitioned... 36667a984708SDavid Chisnall if (__i < __j) 36677a984708SDavid Chisnall { 36687a984708SDavid Chisnall // known that *(__i - 1) < *__m 36697a984708SDavid Chisnall // known that __i <= __m 36707a984708SDavid Chisnall while (true) 36717a984708SDavid Chisnall { 36727a984708SDavid Chisnall // __m still guards upward moving __i 36737a984708SDavid Chisnall while (__comp(*__i, *__m)) 36747a984708SDavid Chisnall ++__i; 36757a984708SDavid Chisnall // It is now known that a guard exists for downward moving __j 36767a984708SDavid Chisnall while (!__comp(*--__j, *__m)) 36777a984708SDavid Chisnall ; 36787a984708SDavid Chisnall if (__i > __j) 36797a984708SDavid Chisnall break; 36807a984708SDavid Chisnall swap(*__i, *__j); 36817a984708SDavid Chisnall ++__n_swaps; 36827a984708SDavid Chisnall // It is known that __m != __j 36837a984708SDavid Chisnall // If __m just moved, follow it 36847a984708SDavid Chisnall if (__m == __i) 36857a984708SDavid Chisnall __m = __j; 36867a984708SDavid Chisnall ++__i; 36877a984708SDavid Chisnall } 36887a984708SDavid Chisnall } 36897a984708SDavid Chisnall // [__first, __i) < *__m and *__m <= [__i, __last) 36907a984708SDavid Chisnall if (__i != __m && __comp(*__m, *__i)) 36917a984708SDavid Chisnall { 36927a984708SDavid Chisnall swap(*__i, *__m); 36937a984708SDavid Chisnall ++__n_swaps; 36947a984708SDavid Chisnall } 36957a984708SDavid Chisnall // [__first, __i) < *__i and *__i <= [__i+1, __last) 36967a984708SDavid Chisnall // If we were given a perfect partition, see if insertion sort is quick... 36977a984708SDavid Chisnall if (__n_swaps == 0) 36987a984708SDavid Chisnall { 36997a984708SDavid Chisnall bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp); 37007a984708SDavid Chisnall if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp)) 37017a984708SDavid Chisnall { 37027a984708SDavid Chisnall if (__fs) 37037a984708SDavid Chisnall return; 37047a984708SDavid Chisnall __last = __i; 37057a984708SDavid Chisnall continue; 37067a984708SDavid Chisnall } 37077a984708SDavid Chisnall else 37087a984708SDavid Chisnall { 37097a984708SDavid Chisnall if (__fs) 37107a984708SDavid Chisnall { 37117a984708SDavid Chisnall __first = ++__i; 37127a984708SDavid Chisnall continue; 37137a984708SDavid Chisnall } 37147a984708SDavid Chisnall } 37157a984708SDavid Chisnall } 37167a984708SDavid Chisnall // sort smaller range with recursive call and larger with tail recursion elimination 37177a984708SDavid Chisnall if (__i - __first < __last - __i) 37187a984708SDavid Chisnall { 37197a984708SDavid Chisnall _VSTD::__sort<_Compare>(__first, __i, __comp); 37207a984708SDavid Chisnall // _VSTD::__sort<_Compare>(__i+1, __last, __comp); 37217a984708SDavid Chisnall __first = ++__i; 37227a984708SDavid Chisnall } 37237a984708SDavid Chisnall else 37247a984708SDavid Chisnall { 37257a984708SDavid Chisnall _VSTD::__sort<_Compare>(__i+1, __last, __comp); 37267a984708SDavid Chisnall // _VSTD::__sort<_Compare>(__first, __i, __comp); 37277a984708SDavid Chisnall __last = __i; 37287a984708SDavid Chisnall } 37297a984708SDavid Chisnall } 37307a984708SDavid Chisnall} 37317a984708SDavid Chisnall 37327a984708SDavid Chisnall// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare 37337a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 37347a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 37357a984708SDavid Chisnallvoid 37367a984708SDavid Chisnallsort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 37377a984708SDavid Chisnall{ 37387a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 37397a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 37407a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 37417a984708SDavid Chisnall __sort<_Comp_ref>(__first, __last, __c); 37427a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 37437a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 37447a984708SDavid Chisnall __sort<_Comp_ref>(__first, __last, __comp); 37457a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 37467a984708SDavid Chisnall} 37477a984708SDavid Chisnall 37487a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 37497a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 37507a984708SDavid Chisnallvoid 37517a984708SDavid Chisnallsort(_RandomAccessIterator __first, _RandomAccessIterator __last) 37527a984708SDavid Chisnall{ 37537a984708SDavid Chisnall _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 37547a984708SDavid Chisnall} 37557a984708SDavid Chisnall 37567a984708SDavid Chisnalltemplate <class _Tp> 37577a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 37587a984708SDavid Chisnallvoid 37597a984708SDavid Chisnallsort(_Tp** __first, _Tp** __last) 37607a984708SDavid Chisnall{ 37617a984708SDavid Chisnall _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>()); 37627a984708SDavid Chisnall} 37637a984708SDavid Chisnall 37647a984708SDavid Chisnalltemplate <class _Tp> 37657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 37667a984708SDavid Chisnallvoid 37677a984708SDavid Chisnallsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last) 37687a984708SDavid Chisnall{ 37697a984708SDavid Chisnall _VSTD::sort(__first.base(), __last.base()); 37707a984708SDavid Chisnall} 37717a984708SDavid Chisnall 37727a984708SDavid Chisnalltemplate <class _Tp, class _Compare> 37737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 37747a984708SDavid Chisnallvoid 37757a984708SDavid Chisnallsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp) 37767a984708SDavid Chisnall{ 37777a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 37787a984708SDavid Chisnall _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp); 37797a984708SDavid Chisnall} 37807a984708SDavid Chisnall 37817a984708SDavid Chisnall#ifdef _MSC_VER 37827a984708SDavid Chisnall#pragma warning( push ) 37837a984708SDavid Chisnall#pragma warning( disable: 4231) 37847a984708SDavid Chisnall#endif // _MSC_VER 37851e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<char>&, char*>(char*, char*, __less<char>&)) 37861e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 37871e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 37881e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 37891e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<short>&, short*>(short*, short*, __less<short>&)) 37901e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 37911e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<int>&, int*>(int*, int*, __less<int>&)) 37921e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 37931e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long>&, long*>(long*, long*, __less<long>&)) 37941e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 37951e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 37961e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&)) 37971e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<float>&, float*>(float*, float*, __less<float>&)) 37981e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<double>&, double*>(double*, double*, __less<double>&)) 37991e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 38007a984708SDavid Chisnall 38011e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&)) 38021e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 38031e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 38041e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 38051e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&)) 38061e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 38071e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&)) 38081e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 38091e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&)) 38101e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 38111e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 38121e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&)) 38131e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&)) 38141e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&)) 38151e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 38167a984708SDavid Chisnall 38171e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&)) 38187a984708SDavid Chisnall#ifdef _MSC_VER 38197a984708SDavid Chisnall#pragma warning( pop ) 382094e3ee44SDavid Chisnall#endif // _MSC_VER 38217a984708SDavid Chisnall 38227a984708SDavid Chisnall// lower_bound 38237a984708SDavid Chisnall 38247a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 38257a984708SDavid Chisnall_ForwardIterator 38267a984708SDavid Chisnall__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 38277a984708SDavid Chisnall{ 38287a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 38297a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 38307a984708SDavid Chisnall while (__len != 0) 38317a984708SDavid Chisnall { 38327a984708SDavid Chisnall difference_type __l2 = __len / 2; 38337a984708SDavid Chisnall _ForwardIterator __m = __first; 38347a984708SDavid Chisnall _VSTD::advance(__m, __l2); 38357a984708SDavid Chisnall if (__comp(*__m, __value_)) 38367a984708SDavid Chisnall { 38377a984708SDavid Chisnall __first = ++__m; 38387a984708SDavid Chisnall __len -= __l2 + 1; 38397a984708SDavid Chisnall } 38407a984708SDavid Chisnall else 38417a984708SDavid Chisnall __len = __l2; 38427a984708SDavid Chisnall } 38437a984708SDavid Chisnall return __first; 38447a984708SDavid Chisnall} 38457a984708SDavid Chisnall 38467a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 38477a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 38487a984708SDavid Chisnall_ForwardIterator 38497a984708SDavid Chisnalllower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 38507a984708SDavid Chisnall{ 38517a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 38527a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 38537a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 38547a984708SDavid Chisnall return __lower_bound<_Comp_ref>(__first, __last, __value_, __c); 38557a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 38567a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 38577a984708SDavid Chisnall return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp); 38587a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 38597a984708SDavid Chisnall} 38607a984708SDavid Chisnall 38617a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 38627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 38637a984708SDavid Chisnall_ForwardIterator 38647a984708SDavid Chisnalllower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 38657a984708SDavid Chisnall{ 38667a984708SDavid Chisnall return _VSTD::lower_bound(__first, __last, __value_, 38677a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 38687a984708SDavid Chisnall} 38697a984708SDavid Chisnall 38707a984708SDavid Chisnall// upper_bound 38717a984708SDavid Chisnall 38727a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 38737a984708SDavid Chisnall_ForwardIterator 38747a984708SDavid Chisnall__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 38757a984708SDavid Chisnall{ 38767a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 38777a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 38787a984708SDavid Chisnall while (__len != 0) 38797a984708SDavid Chisnall { 38807a984708SDavid Chisnall difference_type __l2 = __len / 2; 38817a984708SDavid Chisnall _ForwardIterator __m = __first; 38827a984708SDavid Chisnall _VSTD::advance(__m, __l2); 38837a984708SDavid Chisnall if (__comp(__value_, *__m)) 38847a984708SDavid Chisnall __len = __l2; 38857a984708SDavid Chisnall else 38867a984708SDavid Chisnall { 38877a984708SDavid Chisnall __first = ++__m; 38887a984708SDavid Chisnall __len -= __l2 + 1; 38897a984708SDavid Chisnall } 38907a984708SDavid Chisnall } 38917a984708SDavid Chisnall return __first; 38927a984708SDavid Chisnall} 38937a984708SDavid Chisnall 38947a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 38957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 38967a984708SDavid Chisnall_ForwardIterator 38977a984708SDavid Chisnallupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 38987a984708SDavid Chisnall{ 38997a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 39007a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 39017a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 39027a984708SDavid Chisnall return __upper_bound<_Comp_ref>(__first, __last, __value_, __c); 39037a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 39047a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 39057a984708SDavid Chisnall return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp); 39067a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 39077a984708SDavid Chisnall} 39087a984708SDavid Chisnall 39097a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 39107a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 39117a984708SDavid Chisnall_ForwardIterator 39127a984708SDavid Chisnallupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 39137a984708SDavid Chisnall{ 39147a984708SDavid Chisnall return _VSTD::upper_bound(__first, __last, __value_, 39157a984708SDavid Chisnall __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>()); 39167a984708SDavid Chisnall} 39177a984708SDavid Chisnall 39187a984708SDavid Chisnall// equal_range 39197a984708SDavid Chisnall 39207a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 39217a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator> 39227a984708SDavid Chisnall__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 39237a984708SDavid Chisnall{ 39247a984708SDavid Chisnall typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 39257a984708SDavid Chisnall difference_type __len = _VSTD::distance(__first, __last); 39267a984708SDavid Chisnall while (__len != 0) 39277a984708SDavid Chisnall { 39287a984708SDavid Chisnall difference_type __l2 = __len / 2; 39297a984708SDavid Chisnall _ForwardIterator __m = __first; 39307a984708SDavid Chisnall _VSTD::advance(__m, __l2); 39317a984708SDavid Chisnall if (__comp(*__m, __value_)) 39327a984708SDavid Chisnall { 39337a984708SDavid Chisnall __first = ++__m; 39347a984708SDavid Chisnall __len -= __l2 + 1; 39357a984708SDavid Chisnall } 39367a984708SDavid Chisnall else if (__comp(__value_, *__m)) 39377a984708SDavid Chisnall { 39387a984708SDavid Chisnall __last = __m; 39397a984708SDavid Chisnall __len = __l2; 39407a984708SDavid Chisnall } 39417a984708SDavid Chisnall else 39427a984708SDavid Chisnall { 39437a984708SDavid Chisnall _ForwardIterator __mp1 = __m; 39447a984708SDavid Chisnall return pair<_ForwardIterator, _ForwardIterator> 39457a984708SDavid Chisnall ( 39467a984708SDavid Chisnall __lower_bound<_Compare>(__first, __m, __value_, __comp), 39477a984708SDavid Chisnall __upper_bound<_Compare>(++__mp1, __last, __value_, __comp) 39487a984708SDavid Chisnall ); 39497a984708SDavid Chisnall } 39507a984708SDavid Chisnall } 39517a984708SDavid Chisnall return pair<_ForwardIterator, _ForwardIterator>(__first, __first); 39527a984708SDavid Chisnall} 39537a984708SDavid Chisnall 39547a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 39557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 39567a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator> 39577a984708SDavid Chisnallequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 39587a984708SDavid Chisnall{ 39597a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 39607a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 39617a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 39627a984708SDavid Chisnall return __equal_range<_Comp_ref>(__first, __last, __value_, __c); 39637a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 39647a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 39657a984708SDavid Chisnall return __equal_range<_Comp_ref>(__first, __last, __value_, __comp); 39667a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 39677a984708SDavid Chisnall} 39687a984708SDavid Chisnall 39697a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 39707a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 39717a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator> 39727a984708SDavid Chisnallequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 39737a984708SDavid Chisnall{ 39747a984708SDavid Chisnall return _VSTD::equal_range(__first, __last, __value_, 39757a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 39767a984708SDavid Chisnall} 39777a984708SDavid Chisnall 39787a984708SDavid Chisnall// binary_search 39797a984708SDavid Chisnall 39807a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp> 39817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 39827a984708SDavid Chisnallbool 39837a984708SDavid Chisnall__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 39847a984708SDavid Chisnall{ 39857a984708SDavid Chisnall __first = __lower_bound<_Compare>(__first, __last, __value_, __comp); 39867a984708SDavid Chisnall return __first != __last && !__comp(__value_, *__first); 39877a984708SDavid Chisnall} 39887a984708SDavid Chisnall 39897a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare> 39907a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 39917a984708SDavid Chisnallbool 39927a984708SDavid Chisnallbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 39937a984708SDavid Chisnall{ 39947a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 39957a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 39967a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 39977a984708SDavid Chisnall return __binary_search<_Comp_ref>(__first, __last, __value_, __c); 39987a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 39997a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 40007a984708SDavid Chisnall return __binary_search<_Comp_ref>(__first, __last, __value_, __comp); 40017a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 40027a984708SDavid Chisnall} 40037a984708SDavid Chisnall 40047a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp> 40057a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 40067a984708SDavid Chisnallbool 40077a984708SDavid Chisnallbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 40087a984708SDavid Chisnall{ 40097a984708SDavid Chisnall return _VSTD::binary_search(__first, __last, __value_, 40107a984708SDavid Chisnall __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 40117a984708SDavid Chisnall} 40127a984708SDavid Chisnall 40137a984708SDavid Chisnall// merge 40147a984708SDavid Chisnall 40157a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 40167a984708SDavid Chisnall_OutputIterator 40177a984708SDavid Chisnall__merge(_InputIterator1 __first1, _InputIterator1 __last1, 40187a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 40197a984708SDavid Chisnall{ 40207a984708SDavid Chisnall for (; __first1 != __last1; ++__result) 40217a984708SDavid Chisnall { 40227a984708SDavid Chisnall if (__first2 == __last2) 40237a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 40247a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 40257a984708SDavid Chisnall { 40267a984708SDavid Chisnall *__result = *__first2; 40277a984708SDavid Chisnall ++__first2; 40287a984708SDavid Chisnall } 40297a984708SDavid Chisnall else 40307a984708SDavid Chisnall { 40317a984708SDavid Chisnall *__result = *__first1; 40327a984708SDavid Chisnall ++__first1; 40337a984708SDavid Chisnall } 40347a984708SDavid Chisnall } 40357a984708SDavid Chisnall return _VSTD::copy(__first2, __last2, __result); 40367a984708SDavid Chisnall} 40377a984708SDavid Chisnall 40387a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 40397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 40407a984708SDavid Chisnall_OutputIterator 40417a984708SDavid Chisnallmerge(_InputIterator1 __first1, _InputIterator1 __last1, 40427a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 40437a984708SDavid Chisnall{ 40447a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 40457a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 40467a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 40477a984708SDavid Chisnall return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 40487a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 40497a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 40507a984708SDavid Chisnall return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 40517a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 40527a984708SDavid Chisnall} 40537a984708SDavid Chisnall 40547a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 40557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 40567a984708SDavid Chisnall_OutputIterator 40577a984708SDavid Chisnallmerge(_InputIterator1 __first1, _InputIterator1 __last1, 40587a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 40597a984708SDavid Chisnall{ 40607a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type __v1; 40617a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator2>::value_type __v2; 40627a984708SDavid Chisnall return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>()); 40637a984708SDavid Chisnall} 40647a984708SDavid Chisnall 40657a984708SDavid Chisnall// inplace_merge 40667a984708SDavid Chisnall 40677a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 40687a984708SDavid Chisnallvoid 40697a984708SDavid Chisnall__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 40707a984708SDavid Chisnall _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 40717a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 40727a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::value_type* __buff) 40737a984708SDavid Chisnall{ 40747a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 40757a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 40767a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::pointer pointer; 40777a984708SDavid Chisnall __destruct_n __d(0); 40787a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 40797a984708SDavid Chisnall if (__len1 <= __len2) 40807a984708SDavid Chisnall { 40817a984708SDavid Chisnall value_type* __p = __buff; 40827a984708SDavid Chisnall for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), ++__i, ++__p) 40837a984708SDavid Chisnall ::new(__p) value_type(_VSTD::move(*__i)); 40847a984708SDavid Chisnall __merge<_Compare>(move_iterator<value_type*>(__buff), 40857a984708SDavid Chisnall move_iterator<value_type*>(__p), 40867a984708SDavid Chisnall move_iterator<_BidirectionalIterator>(__middle), 40877a984708SDavid Chisnall move_iterator<_BidirectionalIterator>(__last), 40887a984708SDavid Chisnall __first, __comp); 40897a984708SDavid Chisnall } 40907a984708SDavid Chisnall else 40917a984708SDavid Chisnall { 40927a984708SDavid Chisnall value_type* __p = __buff; 40937a984708SDavid Chisnall for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), ++__i, ++__p) 40947a984708SDavid Chisnall ::new(__p) value_type(_VSTD::move(*__i)); 40957a984708SDavid Chisnall typedef reverse_iterator<_BidirectionalIterator> _RBi; 40967a984708SDavid Chisnall typedef reverse_iterator<value_type*> _Rv; 40977a984708SDavid Chisnall __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)), 40987a984708SDavid Chisnall move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)), 40997a984708SDavid Chisnall _RBi(__last), __negate<_Compare>(__comp)); 41007a984708SDavid Chisnall } 41017a984708SDavid Chisnall} 41027a984708SDavid Chisnall 41037a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 41047a984708SDavid Chisnallvoid 41057a984708SDavid Chisnall__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 41067a984708SDavid Chisnall _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 41077a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 41087a984708SDavid Chisnall typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size) 41097a984708SDavid Chisnall{ 41107a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 41117a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 41127a984708SDavid Chisnall while (true) 41137a984708SDavid Chisnall { 41147a984708SDavid Chisnall // if __middle == __last, we're done 41157a984708SDavid Chisnall if (__len2 == 0) 41167a984708SDavid Chisnall return; 41177a984708SDavid Chisnall // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0 41187a984708SDavid Chisnall for (; true; ++__first, --__len1) 41197a984708SDavid Chisnall { 41207a984708SDavid Chisnall if (__len1 == 0) 41217a984708SDavid Chisnall return; 41227a984708SDavid Chisnall if (__comp(*__middle, *__first)) 41237a984708SDavid Chisnall break; 41247a984708SDavid Chisnall } 41257a984708SDavid Chisnall if (__len1 <= __buff_size || __len2 <= __buff_size) 41267a984708SDavid Chisnall { 41277a984708SDavid Chisnall __buffered_inplace_merge<_Compare>(__first, __middle, __last, __comp, __len1, __len2, __buff); 41287a984708SDavid Chisnall return; 41297a984708SDavid Chisnall } 41307a984708SDavid Chisnall // __first < __middle < __last 41317a984708SDavid Chisnall // *__first > *__middle 41327a984708SDavid Chisnall // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that 41337a984708SDavid Chisnall // all elements in: 41347a984708SDavid Chisnall // [__first, __m1) <= [__middle, __m2) 41357a984708SDavid Chisnall // [__middle, __m2) < [__m1, __middle) 41367a984708SDavid Chisnall // [__m1, __middle) <= [__m2, __last) 41377a984708SDavid Chisnall // and __m1 or __m2 is in the middle of its range 41387a984708SDavid Chisnall _BidirectionalIterator __m1; // "median" of [__first, __middle) 41397a984708SDavid Chisnall _BidirectionalIterator __m2; // "median" of [__middle, __last) 41407a984708SDavid Chisnall difference_type __len11; // distance(__first, __m1) 41417a984708SDavid Chisnall difference_type __len21; // distance(__middle, __m2) 41427a984708SDavid Chisnall // binary search smaller range 41437a984708SDavid Chisnall if (__len1 < __len2) 41447a984708SDavid Chisnall { // __len >= 1, __len2 >= 2 41457a984708SDavid Chisnall __len21 = __len2 / 2; 41467a984708SDavid Chisnall __m2 = __middle; 41477a984708SDavid Chisnall _VSTD::advance(__m2, __len21); 41487a984708SDavid Chisnall __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp); 41497a984708SDavid Chisnall __len11 = _VSTD::distance(__first, __m1); 41507a984708SDavid Chisnall } 41517a984708SDavid Chisnall else 41527a984708SDavid Chisnall { 41537a984708SDavid Chisnall if (__len1 == 1) 41547a984708SDavid Chisnall { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1 41557a984708SDavid Chisnall // It is known *__first > *__middle 41567a984708SDavid Chisnall swap(*__first, *__middle); 41577a984708SDavid Chisnall return; 41587a984708SDavid Chisnall } 41597a984708SDavid Chisnall // __len1 >= 2, __len2 >= 1 41607a984708SDavid Chisnall __len11 = __len1 / 2; 41617a984708SDavid Chisnall __m1 = __first; 41627a984708SDavid Chisnall _VSTD::advance(__m1, __len11); 41637a984708SDavid Chisnall __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp); 41647a984708SDavid Chisnall __len21 = _VSTD::distance(__middle, __m2); 41657a984708SDavid Chisnall } 41667a984708SDavid Chisnall difference_type __len12 = __len1 - __len11; // distance(__m1, __middle) 41677a984708SDavid Chisnall difference_type __len22 = __len2 - __len21; // distance(__m2, __last) 41687a984708SDavid Chisnall // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) 41697a984708SDavid Chisnall // swap middle two partitions 41707a984708SDavid Chisnall __middle = _VSTD::rotate(__m1, __middle, __m2); 41717a984708SDavid Chisnall // __len12 and __len21 now have swapped meanings 41727a984708SDavid Chisnall // merge smaller range with recurisve call and larger with tail recursion elimination 41737a984708SDavid Chisnall if (__len11 + __len21 < __len12 + __len22) 41747a984708SDavid Chisnall { 41757a984708SDavid Chisnall __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 41767a984708SDavid Chisnall// __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 41777a984708SDavid Chisnall __first = __middle; 41787a984708SDavid Chisnall __middle = __m2; 41797a984708SDavid Chisnall __len1 = __len12; 41807a984708SDavid Chisnall __len2 = __len22; 41817a984708SDavid Chisnall } 41827a984708SDavid Chisnall else 41837a984708SDavid Chisnall { 41847a984708SDavid Chisnall __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 41857a984708SDavid Chisnall// __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 41867a984708SDavid Chisnall __last = __middle; 41877a984708SDavid Chisnall __middle = __m1; 41887a984708SDavid Chisnall __len1 = __len11; 41897a984708SDavid Chisnall __len2 = __len21; 41907a984708SDavid Chisnall } 41917a984708SDavid Chisnall } 41927a984708SDavid Chisnall} 41937a984708SDavid Chisnall 41947a984708SDavid Chisnalltemplate <class _Tp> 41957a984708SDavid Chisnallstruct __inplace_merge_switch 41967a984708SDavid Chisnall{ 41977a984708SDavid Chisnall static const unsigned value = is_trivially_copy_assignable<_Tp>::value; 41987a984708SDavid Chisnall}; 41997a984708SDavid Chisnall 42007a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare> 42017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 42027a984708SDavid Chisnallvoid 42037a984708SDavid Chisnallinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 42047a984708SDavid Chisnall _Compare __comp) 42057a984708SDavid Chisnall{ 42067a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 42077a984708SDavid Chisnall typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 42087a984708SDavid Chisnall difference_type __len1 = _VSTD::distance(__first, __middle); 42097a984708SDavid Chisnall difference_type __len2 = _VSTD::distance(__middle, __last); 42107a984708SDavid Chisnall difference_type __buf_size = _VSTD::min(__len1, __len2); 42117a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __buf(0, 0); 42127a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 42137a984708SDavid Chisnall if (__inplace_merge_switch<value_type>::value && __buf_size > 8) 42147a984708SDavid Chisnall { 42157a984708SDavid Chisnall __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size); 42167a984708SDavid Chisnall __h.reset(__buf.first); 42177a984708SDavid Chisnall } 42187a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 42197a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 42207a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 42217a984708SDavid Chisnall return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2, 42227a984708SDavid Chisnall __buf.first, __buf.second); 42237a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 42247a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 42257a984708SDavid Chisnall return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2, 42267a984708SDavid Chisnall __buf.first, __buf.second); 42277a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 42287a984708SDavid Chisnall} 42297a984708SDavid Chisnall 42307a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 42317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 42327a984708SDavid Chisnallvoid 42337a984708SDavid Chisnallinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) 42347a984708SDavid Chisnall{ 42357a984708SDavid Chisnall _VSTD::inplace_merge(__first, __middle, __last, 42367a984708SDavid Chisnall __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 42377a984708SDavid Chisnall} 42387a984708SDavid Chisnall 42397a984708SDavid Chisnall// stable_sort 42407a984708SDavid Chisnall 42417a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2> 42427a984708SDavid Chisnallvoid 42437a984708SDavid Chisnall__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1, 42447a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, 42457a984708SDavid Chisnall typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp) 42467a984708SDavid Chisnall{ 42477a984708SDavid Chisnall typedef typename iterator_traits<_InputIterator1>::value_type value_type; 42487a984708SDavid Chisnall __destruct_n __d(0); 42497a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h(__result, __d); 42507a984708SDavid Chisnall for (; true; ++__result) 42517a984708SDavid Chisnall { 42527a984708SDavid Chisnall if (__first1 == __last1) 42537a984708SDavid Chisnall { 42547a984708SDavid Chisnall for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0)) 42557a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first2)); 42567a984708SDavid Chisnall __h.release(); 42577a984708SDavid Chisnall return; 42587a984708SDavid Chisnall } 42597a984708SDavid Chisnall if (__first2 == __last2) 42607a984708SDavid Chisnall { 42617a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0)) 42627a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first1)); 42637a984708SDavid Chisnall __h.release(); 42647a984708SDavid Chisnall return; 42657a984708SDavid Chisnall } 42667a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 42677a984708SDavid Chisnall { 42687a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first2)); 42697a984708SDavid Chisnall __d.__incr((value_type*)0); 42707a984708SDavid Chisnall ++__first2; 42717a984708SDavid Chisnall } 42727a984708SDavid Chisnall else 42737a984708SDavid Chisnall { 42747a984708SDavid Chisnall ::new (__result) value_type(_VSTD::move(*__first1)); 42757a984708SDavid Chisnall __d.__incr((value_type*)0); 42767a984708SDavid Chisnall ++__first1; 42777a984708SDavid Chisnall } 42787a984708SDavid Chisnall } 42797a984708SDavid Chisnall} 42807a984708SDavid Chisnall 42817a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 42827a984708SDavid Chisnallvoid 42837a984708SDavid Chisnall__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1, 42847a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, 42857a984708SDavid Chisnall _OutputIterator __result, _Compare __comp) 42867a984708SDavid Chisnall{ 42877a984708SDavid Chisnall for (; __first1 != __last1; ++__result) 42887a984708SDavid Chisnall { 42897a984708SDavid Chisnall if (__first2 == __last2) 42907a984708SDavid Chisnall { 42917a984708SDavid Chisnall for (; __first1 != __last1; ++__first1, ++__result) 42927a984708SDavid Chisnall *__result = _VSTD::move(*__first1); 42937a984708SDavid Chisnall return; 42947a984708SDavid Chisnall } 42957a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 42967a984708SDavid Chisnall { 42977a984708SDavid Chisnall *__result = _VSTD::move(*__first2); 42987a984708SDavid Chisnall ++__first2; 42997a984708SDavid Chisnall } 43007a984708SDavid Chisnall else 43017a984708SDavid Chisnall { 43027a984708SDavid Chisnall *__result = _VSTD::move(*__first1); 43037a984708SDavid Chisnall ++__first1; 43047a984708SDavid Chisnall } 43057a984708SDavid Chisnall } 43067a984708SDavid Chisnall for (; __first2 != __last2; ++__first2, ++__result) 43077a984708SDavid Chisnall *__result = _VSTD::move(*__first2); 43087a984708SDavid Chisnall} 43097a984708SDavid Chisnall 43107a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 43117a984708SDavid Chisnallvoid 43127a984708SDavid Chisnall__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 43137a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len, 43147a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size); 43157a984708SDavid Chisnall 43167a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 43177a984708SDavid Chisnallvoid 43187a984708SDavid Chisnall__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp, 43197a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len, 43207a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::value_type* __first2) 43217a984708SDavid Chisnall{ 43227a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 43237a984708SDavid Chisnall switch (__len) 43247a984708SDavid Chisnall { 43257a984708SDavid Chisnall case 0: 43267a984708SDavid Chisnall return; 43277a984708SDavid Chisnall case 1: 43287a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__first1)); 43297a984708SDavid Chisnall return; 43307a984708SDavid Chisnall case 2: 43317a984708SDavid Chisnall __destruct_n __d(0); 43327a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h2(__first2, __d); 43337a984708SDavid Chisnall if (__comp(*--__last1, *__first1)) 43347a984708SDavid Chisnall { 43357a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__last1)); 43367a984708SDavid Chisnall __d.__incr((value_type*)0); 43377a984708SDavid Chisnall ++__first2; 43387a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__first1)); 43397a984708SDavid Chisnall } 43407a984708SDavid Chisnall else 43417a984708SDavid Chisnall { 43427a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__first1)); 43437a984708SDavid Chisnall __d.__incr((value_type*)0); 43447a984708SDavid Chisnall ++__first2; 43457a984708SDavid Chisnall ::new(__first2) value_type(_VSTD::move(*__last1)); 43467a984708SDavid Chisnall } 43477a984708SDavid Chisnall __h2.release(); 43487a984708SDavid Chisnall return; 43497a984708SDavid Chisnall } 43507a984708SDavid Chisnall if (__len <= 8) 43517a984708SDavid Chisnall { 43527a984708SDavid Chisnall __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp); 43537a984708SDavid Chisnall return; 43547a984708SDavid Chisnall } 43557a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 43567a984708SDavid Chisnall _RandomAccessIterator __m = __first1 + __l2; 43577a984708SDavid Chisnall __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2); 43587a984708SDavid Chisnall __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2); 43597a984708SDavid Chisnall __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp); 43607a984708SDavid Chisnall} 43617a984708SDavid Chisnall 43627a984708SDavid Chisnalltemplate <class _Tp> 43637a984708SDavid Chisnallstruct __stable_sort_switch 43647a984708SDavid Chisnall{ 43657a984708SDavid Chisnall static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value; 43667a984708SDavid Chisnall}; 43677a984708SDavid Chisnall 43687a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 43697a984708SDavid Chisnallvoid 43707a984708SDavid Chisnall__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 43717a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len, 43727a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size) 43737a984708SDavid Chisnall{ 43747a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 43757a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 43767a984708SDavid Chisnall switch (__len) 43777a984708SDavid Chisnall { 43787a984708SDavid Chisnall case 0: 43797a984708SDavid Chisnall case 1: 43807a984708SDavid Chisnall return; 43817a984708SDavid Chisnall case 2: 43827a984708SDavid Chisnall if (__comp(*--__last, *__first)) 43837a984708SDavid Chisnall swap(*__first, *__last); 43847a984708SDavid Chisnall return; 43857a984708SDavid Chisnall } 43867a984708SDavid Chisnall if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 43877a984708SDavid Chisnall { 43887a984708SDavid Chisnall __insertion_sort<_Compare>(__first, __last, __comp); 43897a984708SDavid Chisnall return; 43907a984708SDavid Chisnall } 43917a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 43927a984708SDavid Chisnall _RandomAccessIterator __m = __first + __l2; 43937a984708SDavid Chisnall if (__len <= __buff_size) 43947a984708SDavid Chisnall { 43957a984708SDavid Chisnall __destruct_n __d(0); 43967a984708SDavid Chisnall unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 43977a984708SDavid Chisnall __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff); 43987a984708SDavid Chisnall __d.__set(__l2, (value_type*)0); 43997a984708SDavid Chisnall __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2); 44007a984708SDavid Chisnall __d.__set(__len, (value_type*)0); 44017a984708SDavid Chisnall __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp); 44027a984708SDavid Chisnall// __merge<_Compare>(move_iterator<value_type*>(__buff), 44037a984708SDavid Chisnall// move_iterator<value_type*>(__buff + __l2), 44047a984708SDavid Chisnall// move_iterator<_RandomAccessIterator>(__buff + __l2), 44057a984708SDavid Chisnall// move_iterator<_RandomAccessIterator>(__buff + __len), 44067a984708SDavid Chisnall// __first, __comp); 44077a984708SDavid Chisnall return; 44087a984708SDavid Chisnall } 44097a984708SDavid Chisnall __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size); 44107a984708SDavid Chisnall __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size); 44117a984708SDavid Chisnall __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size); 44127a984708SDavid Chisnall} 44137a984708SDavid Chisnall 44147a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 44157a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 44167a984708SDavid Chisnallvoid 44177a984708SDavid Chisnallstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 44187a984708SDavid Chisnall{ 44197a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 44207a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 44217a984708SDavid Chisnall difference_type __len = __last - __first; 44227a984708SDavid Chisnall pair<value_type*, ptrdiff_t> __buf(0, 0); 44237a984708SDavid Chisnall unique_ptr<value_type, __return_temporary_buffer> __h; 44247a984708SDavid Chisnall if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 44257a984708SDavid Chisnall { 44267a984708SDavid Chisnall __buf = _VSTD::get_temporary_buffer<value_type>(__len); 44277a984708SDavid Chisnall __h.reset(__buf.first); 44287a984708SDavid Chisnall } 44297a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 44307a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 44317a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 44327a984708SDavid Chisnall __stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second); 44337a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 44347a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 44357a984708SDavid Chisnall __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second); 44367a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 44377a984708SDavid Chisnall} 44387a984708SDavid Chisnall 44397a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 44407a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 44417a984708SDavid Chisnallvoid 44427a984708SDavid Chisnallstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) 44437a984708SDavid Chisnall{ 44447a984708SDavid Chisnall _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 44457a984708SDavid Chisnall} 44467a984708SDavid Chisnall 44477a984708SDavid Chisnall// is_heap_until 44487a984708SDavid Chisnall 44497a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 44507a984708SDavid Chisnall_RandomAccessIterator 44517a984708SDavid Chisnallis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 44527a984708SDavid Chisnall{ 44537a984708SDavid Chisnall typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type; 44547a984708SDavid Chisnall difference_type __len = __last - __first; 44557a984708SDavid Chisnall difference_type __p = 0; 44567a984708SDavid Chisnall difference_type __c = 1; 44577a984708SDavid Chisnall _RandomAccessIterator __pp = __first; 44587a984708SDavid Chisnall while (__c < __len) 44597a984708SDavid Chisnall { 44607a984708SDavid Chisnall _RandomAccessIterator __cp = __first + __c; 44617a984708SDavid Chisnall if (__comp(*__pp, *__cp)) 44627a984708SDavid Chisnall return __cp; 44637a984708SDavid Chisnall ++__c; 44647a984708SDavid Chisnall ++__cp; 44657a984708SDavid Chisnall if (__c == __len) 44667a984708SDavid Chisnall return __last; 44677a984708SDavid Chisnall if (__comp(*__pp, *__cp)) 44687a984708SDavid Chisnall return __cp; 44697a984708SDavid Chisnall ++__p; 44707a984708SDavid Chisnall ++__pp; 44717a984708SDavid Chisnall __c = 2 * __p + 1; 44727a984708SDavid Chisnall } 44737a984708SDavid Chisnall return __last; 44747a984708SDavid Chisnall} 44757a984708SDavid Chisnall 44767a984708SDavid Chisnalltemplate<class _RandomAccessIterator> 44777a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 44787a984708SDavid Chisnall_RandomAccessIterator 44797a984708SDavid Chisnallis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) 44807a984708SDavid Chisnall{ 44817a984708SDavid Chisnall return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 44827a984708SDavid Chisnall} 44837a984708SDavid Chisnall 44847a984708SDavid Chisnall// is_heap 44857a984708SDavid Chisnall 44867a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 44877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 44887a984708SDavid Chisnallbool 44897a984708SDavid Chisnallis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 44907a984708SDavid Chisnall{ 44917a984708SDavid Chisnall return _VSTD::is_heap_until(__first, __last, __comp) == __last; 44927a984708SDavid Chisnall} 44937a984708SDavid Chisnall 44947a984708SDavid Chisnalltemplate<class _RandomAccessIterator> 44957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 44967a984708SDavid Chisnallbool 44977a984708SDavid Chisnallis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 44987a984708SDavid Chisnall{ 44997a984708SDavid Chisnall return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 45007a984708SDavid Chisnall} 45017a984708SDavid Chisnall 45027a984708SDavid Chisnall// push_heap 45037a984708SDavid Chisnall 45047a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 45057a984708SDavid Chisnallvoid 45067a984708SDavid Chisnall__push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare __comp, 45077a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len) 45087a984708SDavid Chisnall{ 45097a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 45107a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 45117a984708SDavid Chisnall if (__len > 1) 45127a984708SDavid Chisnall { 45137a984708SDavid Chisnall difference_type __p = 0; 45147a984708SDavid Chisnall _RandomAccessIterator __pp = __first; 45157a984708SDavid Chisnall difference_type __c = 2; 45167a984708SDavid Chisnall _RandomAccessIterator __cp = __first + __c; 45177a984708SDavid Chisnall if (__c == __len || __comp(*__cp, *(__cp - 1))) 45187a984708SDavid Chisnall { 45197a984708SDavid Chisnall --__c; 45207a984708SDavid Chisnall --__cp; 45217a984708SDavid Chisnall } 45227a984708SDavid Chisnall if (__comp(*__pp, *__cp)) 45237a984708SDavid Chisnall { 45247a984708SDavid Chisnall value_type __t(_VSTD::move(*__pp)); 45257a984708SDavid Chisnall do 45267a984708SDavid Chisnall { 45277a984708SDavid Chisnall *__pp = _VSTD::move(*__cp); 45287a984708SDavid Chisnall __pp = __cp; 45297a984708SDavid Chisnall __p = __c; 45307a984708SDavid Chisnall __c = (__p + 1) * 2; 45317a984708SDavid Chisnall if (__c > __len) 45327a984708SDavid Chisnall break; 45337a984708SDavid Chisnall __cp = __first + __c; 45347a984708SDavid Chisnall if (__c == __len || __comp(*__cp, *(__cp - 1))) 45357a984708SDavid Chisnall { 45367a984708SDavid Chisnall --__c; 45377a984708SDavid Chisnall --__cp; 45387a984708SDavid Chisnall } 45397a984708SDavid Chisnall } while (__comp(__t, *__cp)); 45407a984708SDavid Chisnall *__pp = _VSTD::move(__t); 45417a984708SDavid Chisnall } 45427a984708SDavid Chisnall } 45437a984708SDavid Chisnall} 45447a984708SDavid Chisnall 45457a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 45467a984708SDavid Chisnallvoid 45477a984708SDavid Chisnall__push_heap_back(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 45487a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len) 45497a984708SDavid Chisnall{ 45507a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 45517a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 45527a984708SDavid Chisnall if (__len > 1) 45537a984708SDavid Chisnall { 45547a984708SDavid Chisnall __len = (__len - 2) / 2; 45557a984708SDavid Chisnall _RandomAccessIterator __ptr = __first + __len; 45567a984708SDavid Chisnall if (__comp(*__ptr, *--__last)) 45577a984708SDavid Chisnall { 45587a984708SDavid Chisnall value_type __t(_VSTD::move(*__last)); 45597a984708SDavid Chisnall do 45607a984708SDavid Chisnall { 45617a984708SDavid Chisnall *__last = _VSTD::move(*__ptr); 45627a984708SDavid Chisnall __last = __ptr; 45637a984708SDavid Chisnall if (__len == 0) 45647a984708SDavid Chisnall break; 45657a984708SDavid Chisnall __len = (__len - 1) / 2; 45667a984708SDavid Chisnall __ptr = __first + __len; 45677a984708SDavid Chisnall } while (__comp(*__ptr, __t)); 45687a984708SDavid Chisnall *__last = _VSTD::move(__t); 45697a984708SDavid Chisnall } 45707a984708SDavid Chisnall } 45717a984708SDavid Chisnall} 45727a984708SDavid Chisnall 45737a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 45747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 45757a984708SDavid Chisnallvoid 45767a984708SDavid Chisnallpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 45777a984708SDavid Chisnall{ 45787a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 45797a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 45807a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 45817a984708SDavid Chisnall __push_heap_back<_Comp_ref>(__first, __last, __c, __last - __first); 45827a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 45837a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 45847a984708SDavid Chisnall __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first); 45857a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 45867a984708SDavid Chisnall} 45877a984708SDavid Chisnall 45887a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 45897a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 45907a984708SDavid Chisnallvoid 45917a984708SDavid Chisnallpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 45927a984708SDavid Chisnall{ 45937a984708SDavid Chisnall _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 45947a984708SDavid Chisnall} 45957a984708SDavid Chisnall 45967a984708SDavid Chisnall// pop_heap 45977a984708SDavid Chisnall 45987a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 45997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 46007a984708SDavid Chisnallvoid 46017a984708SDavid Chisnall__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 46027a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len) 46037a984708SDavid Chisnall{ 46047a984708SDavid Chisnall if (__len > 1) 46057a984708SDavid Chisnall { 46067a984708SDavid Chisnall swap(*__first, *--__last); 46077a984708SDavid Chisnall __push_heap_front<_Compare>(__first, __last, __comp, __len-1); 46087a984708SDavid Chisnall } 46097a984708SDavid Chisnall} 46107a984708SDavid Chisnall 46117a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 46127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 46137a984708SDavid Chisnallvoid 46147a984708SDavid Chisnallpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 46157a984708SDavid Chisnall{ 46167a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 46177a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 46187a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 46197a984708SDavid Chisnall __pop_heap<_Comp_ref>(__first, __last, __c, __last - __first); 46207a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 46217a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 46227a984708SDavid Chisnall __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first); 46237a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 46247a984708SDavid Chisnall} 46257a984708SDavid Chisnall 46267a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 46277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 46287a984708SDavid Chisnallvoid 46297a984708SDavid Chisnallpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 46307a984708SDavid Chisnall{ 46317a984708SDavid Chisnall _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 46327a984708SDavid Chisnall} 46337a984708SDavid Chisnall 46347a984708SDavid Chisnall// make_heap 46357a984708SDavid Chisnall 46367a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 46377a984708SDavid Chisnallvoid 46387a984708SDavid Chisnall__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 46397a984708SDavid Chisnall{ 46407a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 46417a984708SDavid Chisnall difference_type __n = __last - __first; 46427a984708SDavid Chisnall if (__n > 1) 46437a984708SDavid Chisnall { 46447a984708SDavid Chisnall __last = __first; 46457a984708SDavid Chisnall ++__last; 46467a984708SDavid Chisnall for (difference_type __i = 1; __i < __n;) 46477a984708SDavid Chisnall __push_heap_back<_Compare>(__first, ++__last, __comp, ++__i); 46487a984708SDavid Chisnall } 46497a984708SDavid Chisnall} 46507a984708SDavid Chisnall 46517a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 46527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 46537a984708SDavid Chisnallvoid 46547a984708SDavid Chisnallmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 46557a984708SDavid Chisnall{ 46567a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 46577a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 46587a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 46597a984708SDavid Chisnall __make_heap<_Comp_ref>(__first, __last, __c); 46607a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 46617a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 46627a984708SDavid Chisnall __make_heap<_Comp_ref>(__first, __last, __comp); 46637a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 46647a984708SDavid Chisnall} 46657a984708SDavid Chisnall 46667a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 46677a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 46687a984708SDavid Chisnallvoid 46697a984708SDavid Chisnallmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 46707a984708SDavid Chisnall{ 46717a984708SDavid Chisnall _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 46727a984708SDavid Chisnall} 46737a984708SDavid Chisnall 46747a984708SDavid Chisnall// sort_heap 46757a984708SDavid Chisnall 46767a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 46777a984708SDavid Chisnallvoid 46787a984708SDavid Chisnall__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 46797a984708SDavid Chisnall{ 46807a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 46817a984708SDavid Chisnall for (difference_type __n = __last - __first; __n > 1; --__last, --__n) 46827a984708SDavid Chisnall __pop_heap<_Compare>(__first, __last, __comp, __n); 46837a984708SDavid Chisnall} 46847a984708SDavid Chisnall 46857a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 46867a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 46877a984708SDavid Chisnallvoid 46887a984708SDavid Chisnallsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 46897a984708SDavid Chisnall{ 46907a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 46917a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 46927a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 46937a984708SDavid Chisnall __sort_heap<_Comp_ref>(__first, __last, __c); 46947a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 46957a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 46967a984708SDavid Chisnall __sort_heap<_Comp_ref>(__first, __last, __comp); 46977a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 46987a984708SDavid Chisnall} 46997a984708SDavid Chisnall 47007a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 47017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47027a984708SDavid Chisnallvoid 47037a984708SDavid Chisnallsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 47047a984708SDavid Chisnall{ 47057a984708SDavid Chisnall _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 47067a984708SDavid Chisnall} 47077a984708SDavid Chisnall 47087a984708SDavid Chisnall// partial_sort 47097a984708SDavid Chisnall 47107a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 47117a984708SDavid Chisnallvoid 47127a984708SDavid Chisnall__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 47137a984708SDavid Chisnall _Compare __comp) 47147a984708SDavid Chisnall{ 47157a984708SDavid Chisnall __make_heap<_Compare>(__first, __middle, __comp); 47167a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first; 47177a984708SDavid Chisnall for (_RandomAccessIterator __i = __middle; __i != __last; ++__i) 47187a984708SDavid Chisnall { 47197a984708SDavid Chisnall if (__comp(*__i, *__first)) 47207a984708SDavid Chisnall { 47217a984708SDavid Chisnall swap(*__i, *__first); 47227a984708SDavid Chisnall __push_heap_front<_Compare>(__first, __middle, __comp, __len); 47237a984708SDavid Chisnall } 47247a984708SDavid Chisnall } 47257a984708SDavid Chisnall __sort_heap<_Compare>(__first, __middle, __comp); 47267a984708SDavid Chisnall} 47277a984708SDavid Chisnall 47287a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 47297a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47307a984708SDavid Chisnallvoid 47317a984708SDavid Chisnallpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 47327a984708SDavid Chisnall _Compare __comp) 47337a984708SDavid Chisnall{ 47347a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 47357a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 47367a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 47377a984708SDavid Chisnall __partial_sort<_Comp_ref>(__first, __middle, __last, __c); 47387a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 47397a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 47407a984708SDavid Chisnall __partial_sort<_Comp_ref>(__first, __middle, __last, __comp); 47417a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 47427a984708SDavid Chisnall} 47437a984708SDavid Chisnall 47447a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 47457a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47467a984708SDavid Chisnallvoid 47477a984708SDavid Chisnallpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 47487a984708SDavid Chisnall{ 47497a984708SDavid Chisnall _VSTD::partial_sort(__first, __middle, __last, 47507a984708SDavid Chisnall __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 47517a984708SDavid Chisnall} 47527a984708SDavid Chisnall 47537a984708SDavid Chisnall// partial_sort_copy 47547a984708SDavid Chisnall 47557a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator, class _RandomAccessIterator> 47567a984708SDavid Chisnall_RandomAccessIterator 47577a984708SDavid Chisnall__partial_sort_copy(_InputIterator __first, _InputIterator __last, 47587a984708SDavid Chisnall _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 47597a984708SDavid Chisnall{ 47607a984708SDavid Chisnall _RandomAccessIterator __r = __result_first; 47617a984708SDavid Chisnall if (__r != __result_last) 47627a984708SDavid Chisnall { 47637a984708SDavid Chisnall typename iterator_traits<_RandomAccessIterator>::difference_type __len = 0; 47647a984708SDavid Chisnall for (; __first != __last && __r != __result_last; ++__first, ++__r, ++__len) 47657a984708SDavid Chisnall *__r = *__first; 47667a984708SDavid Chisnall __make_heap<_Compare>(__result_first, __r, __comp); 47677a984708SDavid Chisnall for (; __first != __last; ++__first) 47687a984708SDavid Chisnall if (__comp(*__first, *__result_first)) 47697a984708SDavid Chisnall { 47707a984708SDavid Chisnall *__result_first = *__first; 47717a984708SDavid Chisnall __push_heap_front<_Compare>(__result_first, __r, __comp, __len); 47727a984708SDavid Chisnall } 47737a984708SDavid Chisnall __sort_heap<_Compare>(__result_first, __r, __comp); 47747a984708SDavid Chisnall } 47757a984708SDavid Chisnall return __r; 47767a984708SDavid Chisnall} 47777a984708SDavid Chisnall 47787a984708SDavid Chisnalltemplate <class _InputIterator, class _RandomAccessIterator, class _Compare> 47797a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47807a984708SDavid Chisnall_RandomAccessIterator 47817a984708SDavid Chisnallpartial_sort_copy(_InputIterator __first, _InputIterator __last, 47827a984708SDavid Chisnall _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 47837a984708SDavid Chisnall{ 47847a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 47857a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 47867a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 47877a984708SDavid Chisnall return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c); 47887a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 47897a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 47907a984708SDavid Chisnall return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp); 47917a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 47927a984708SDavid Chisnall} 47937a984708SDavid Chisnall 47947a984708SDavid Chisnalltemplate <class _InputIterator, class _RandomAccessIterator> 47957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 47967a984708SDavid Chisnall_RandomAccessIterator 47977a984708SDavid Chisnallpartial_sort_copy(_InputIterator __first, _InputIterator __last, 47987a984708SDavid Chisnall _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) 47997a984708SDavid Chisnall{ 48007a984708SDavid Chisnall return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last, 48017a984708SDavid Chisnall __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 48027a984708SDavid Chisnall} 48037a984708SDavid Chisnall 48047a984708SDavid Chisnall// nth_element 48057a984708SDavid Chisnall 48067a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator> 48077a984708SDavid Chisnallvoid 48087a984708SDavid Chisnall__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 48097a984708SDavid Chisnall{ 48107a984708SDavid Chisnall // _Compare is known to be a reference type 48117a984708SDavid Chisnall typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 48127a984708SDavid Chisnall const difference_type __limit = 7; 48137a984708SDavid Chisnall while (true) 48147a984708SDavid Chisnall { 48157a984708SDavid Chisnall __restart: 481694e3ee44SDavid Chisnall if (__nth == __last) 481794e3ee44SDavid Chisnall return; 48187a984708SDavid Chisnall difference_type __len = __last - __first; 48197a984708SDavid Chisnall switch (__len) 48207a984708SDavid Chisnall { 48217a984708SDavid Chisnall case 0: 48227a984708SDavid Chisnall case 1: 48237a984708SDavid Chisnall return; 48247a984708SDavid Chisnall case 2: 48257a984708SDavid Chisnall if (__comp(*--__last, *__first)) 48267a984708SDavid Chisnall swap(*__first, *__last); 48277a984708SDavid Chisnall return; 48287a984708SDavid Chisnall case 3: 48297a984708SDavid Chisnall { 48307a984708SDavid Chisnall _RandomAccessIterator __m = __first; 48317a984708SDavid Chisnall _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp); 48327a984708SDavid Chisnall return; 48337a984708SDavid Chisnall } 48347a984708SDavid Chisnall } 48357a984708SDavid Chisnall if (__len <= __limit) 48367a984708SDavid Chisnall { 48377a984708SDavid Chisnall __selection_sort<_Compare>(__first, __last, __comp); 48387a984708SDavid Chisnall return; 48397a984708SDavid Chisnall } 48407a984708SDavid Chisnall // __len > __limit >= 3 48417a984708SDavid Chisnall _RandomAccessIterator __m = __first + __len/2; 48427a984708SDavid Chisnall _RandomAccessIterator __lm1 = __last; 48437a984708SDavid Chisnall unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp); 48447a984708SDavid Chisnall // *__m is median 48457a984708SDavid Chisnall // partition [__first, __m) < *__m and *__m <= [__m, __last) 48467a984708SDavid Chisnall // (this inhibits tossing elements equivalent to __m around unnecessarily) 48477a984708SDavid Chisnall _RandomAccessIterator __i = __first; 48487a984708SDavid Chisnall _RandomAccessIterator __j = __lm1; 48497a984708SDavid Chisnall // j points beyond range to be tested, *__lm1 is known to be <= *__m 48507a984708SDavid Chisnall // The search going up is known to be guarded but the search coming down isn't. 48517a984708SDavid Chisnall // Prime the downward search with a guard. 48527a984708SDavid Chisnall if (!__comp(*__i, *__m)) // if *__first == *__m 48537a984708SDavid Chisnall { 48547a984708SDavid Chisnall // *__first == *__m, *__first doesn't go in first part 48557a984708SDavid Chisnall // manually guard downward moving __j against __i 48567a984708SDavid Chisnall while (true) 48577a984708SDavid Chisnall { 48587a984708SDavid Chisnall if (__i == --__j) 48597a984708SDavid Chisnall { 48607a984708SDavid Chisnall // *__first == *__m, *__m <= all other elements 48617a984708SDavid Chisnall // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 48627a984708SDavid Chisnall ++__i; // __first + 1 48637a984708SDavid Chisnall __j = __last; 48647a984708SDavid Chisnall if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 48657a984708SDavid Chisnall { 48667a984708SDavid Chisnall while (true) 48677a984708SDavid Chisnall { 48687a984708SDavid Chisnall if (__i == __j) 48697a984708SDavid Chisnall return; // [__first, __last) all equivalent elements 48707a984708SDavid Chisnall if (__comp(*__first, *__i)) 48717a984708SDavid Chisnall { 48727a984708SDavid Chisnall swap(*__i, *__j); 48737a984708SDavid Chisnall ++__n_swaps; 48747a984708SDavid Chisnall ++__i; 48757a984708SDavid Chisnall break; 48767a984708SDavid Chisnall } 48777a984708SDavid Chisnall ++__i; 48787a984708SDavid Chisnall } 48797a984708SDavid Chisnall } 48807a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 48817a984708SDavid Chisnall if (__i == __j) 48827a984708SDavid Chisnall return; 48837a984708SDavid Chisnall while (true) 48847a984708SDavid Chisnall { 48857a984708SDavid Chisnall while (!__comp(*__first, *__i)) 48867a984708SDavid Chisnall ++__i; 48877a984708SDavid Chisnall while (__comp(*__first, *--__j)) 48887a984708SDavid Chisnall ; 48897a984708SDavid Chisnall if (__i >= __j) 48907a984708SDavid Chisnall break; 48917a984708SDavid Chisnall swap(*__i, *__j); 48927a984708SDavid Chisnall ++__n_swaps; 48937a984708SDavid Chisnall ++__i; 48947a984708SDavid Chisnall } 48957a984708SDavid Chisnall // [__first, __i) == *__first and *__first < [__i, __last) 48967a984708SDavid Chisnall // The first part is sorted, 48977a984708SDavid Chisnall if (__nth < __i) 48987a984708SDavid Chisnall return; 48997a984708SDavid Chisnall // __nth_element the secod part 49007a984708SDavid Chisnall // __nth_element<_Compare>(__i, __nth, __last, __comp); 49017a984708SDavid Chisnall __first = __i; 49027a984708SDavid Chisnall goto __restart; 49037a984708SDavid Chisnall } 49047a984708SDavid Chisnall if (__comp(*__j, *__m)) 49057a984708SDavid Chisnall { 49067a984708SDavid Chisnall swap(*__i, *__j); 49077a984708SDavid Chisnall ++__n_swaps; 49087a984708SDavid Chisnall break; // found guard for downward moving __j, now use unguarded partition 49097a984708SDavid Chisnall } 49107a984708SDavid Chisnall } 49117a984708SDavid Chisnall } 49127a984708SDavid Chisnall ++__i; 49137a984708SDavid Chisnall // j points beyond range to be tested, *__lm1 is known to be <= *__m 49147a984708SDavid Chisnall // if not yet partitioned... 49157a984708SDavid Chisnall if (__i < __j) 49167a984708SDavid Chisnall { 49177a984708SDavid Chisnall // known that *(__i - 1) < *__m 49187a984708SDavid Chisnall while (true) 49197a984708SDavid Chisnall { 49207a984708SDavid Chisnall // __m still guards upward moving __i 49217a984708SDavid Chisnall while (__comp(*__i, *__m)) 49227a984708SDavid Chisnall ++__i; 49237a984708SDavid Chisnall // It is now known that a guard exists for downward moving __j 49247a984708SDavid Chisnall while (!__comp(*--__j, *__m)) 49257a984708SDavid Chisnall ; 49267a984708SDavid Chisnall if (__i >= __j) 49277a984708SDavid Chisnall break; 49287a984708SDavid Chisnall swap(*__i, *__j); 49297a984708SDavid Chisnall ++__n_swaps; 49307a984708SDavid Chisnall // It is known that __m != __j 49317a984708SDavid Chisnall // If __m just moved, follow it 49327a984708SDavid Chisnall if (__m == __i) 49337a984708SDavid Chisnall __m = __j; 49347a984708SDavid Chisnall ++__i; 49357a984708SDavid Chisnall } 49367a984708SDavid Chisnall } 49377a984708SDavid Chisnall // [__first, __i) < *__m and *__m <= [__i, __last) 49387a984708SDavid Chisnall if (__i != __m && __comp(*__m, *__i)) 49397a984708SDavid Chisnall { 49407a984708SDavid Chisnall swap(*__i, *__m); 49417a984708SDavid Chisnall ++__n_swaps; 49427a984708SDavid Chisnall } 49437a984708SDavid Chisnall // [__first, __i) < *__i and *__i <= [__i+1, __last) 49447a984708SDavid Chisnall if (__nth == __i) 49457a984708SDavid Chisnall return; 49467a984708SDavid Chisnall if (__n_swaps == 0) 49477a984708SDavid Chisnall { 49487a984708SDavid Chisnall // We were given a perfectly partitioned sequence. Coincidence? 49497a984708SDavid Chisnall if (__nth < __i) 49507a984708SDavid Chisnall { 49517a984708SDavid Chisnall // Check for [__first, __i) already sorted 49527a984708SDavid Chisnall __j = __m = __first; 49537a984708SDavid Chisnall while (++__j != __i) 49547a984708SDavid Chisnall { 49557a984708SDavid Chisnall if (__comp(*__j, *__m)) 49567a984708SDavid Chisnall // not yet sorted, so sort 49577a984708SDavid Chisnall goto not_sorted; 49587a984708SDavid Chisnall __m = __j; 49597a984708SDavid Chisnall } 49607a984708SDavid Chisnall // [__first, __i) sorted 49617a984708SDavid Chisnall return; 49627a984708SDavid Chisnall } 49637a984708SDavid Chisnall else 49647a984708SDavid Chisnall { 49657a984708SDavid Chisnall // Check for [__i, __last) already sorted 49667a984708SDavid Chisnall __j = __m = __i; 49677a984708SDavid Chisnall while (++__j != __last) 49687a984708SDavid Chisnall { 49697a984708SDavid Chisnall if (__comp(*__j, *__m)) 49707a984708SDavid Chisnall // not yet sorted, so sort 49717a984708SDavid Chisnall goto not_sorted; 49727a984708SDavid Chisnall __m = __j; 49737a984708SDavid Chisnall } 49747a984708SDavid Chisnall // [__i, __last) sorted 49757a984708SDavid Chisnall return; 49767a984708SDavid Chisnall } 49777a984708SDavid Chisnall } 49787a984708SDavid Chisnallnot_sorted: 49797a984708SDavid Chisnall // __nth_element on range containing __nth 49807a984708SDavid Chisnall if (__nth < __i) 49817a984708SDavid Chisnall { 49827a984708SDavid Chisnall // __nth_element<_Compare>(__first, __nth, __i, __comp); 49837a984708SDavid Chisnall __last = __i; 49847a984708SDavid Chisnall } 49857a984708SDavid Chisnall else 49867a984708SDavid Chisnall { 49877a984708SDavid Chisnall // __nth_element<_Compare>(__i+1, __nth, __last, __comp); 49887a984708SDavid Chisnall __first = ++__i; 49897a984708SDavid Chisnall } 49907a984708SDavid Chisnall } 49917a984708SDavid Chisnall} 49927a984708SDavid Chisnall 49937a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare> 49947a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 49957a984708SDavid Chisnallvoid 49967a984708SDavid Chisnallnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 49977a984708SDavid Chisnall{ 49987a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 49997a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 50007a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 50017a984708SDavid Chisnall __nth_element<_Comp_ref>(__first, __nth, __last, __c); 50027a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 50037a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 50047a984708SDavid Chisnall __nth_element<_Comp_ref>(__first, __nth, __last, __comp); 50057a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 50067a984708SDavid Chisnall} 50077a984708SDavid Chisnall 50087a984708SDavid Chisnalltemplate <class _RandomAccessIterator> 50097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50107a984708SDavid Chisnallvoid 50117a984708SDavid Chisnallnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) 50127a984708SDavid Chisnall{ 50137a984708SDavid Chisnall _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 50147a984708SDavid Chisnall} 50157a984708SDavid Chisnall 50167a984708SDavid Chisnall// includes 50177a984708SDavid Chisnall 50187a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2> 50197a984708SDavid Chisnallbool 50207a984708SDavid Chisnall__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 50217a984708SDavid Chisnall _Compare __comp) 50227a984708SDavid Chisnall{ 50237a984708SDavid Chisnall for (; __first2 != __last2; ++__first1) 50247a984708SDavid Chisnall { 50257a984708SDavid Chisnall if (__first1 == __last1 || __comp(*__first2, *__first1)) 50267a984708SDavid Chisnall return false; 50277a984708SDavid Chisnall if (!__comp(*__first1, *__first2)) 50287a984708SDavid Chisnall ++__first2; 50297a984708SDavid Chisnall } 50307a984708SDavid Chisnall return true; 50317a984708SDavid Chisnall} 50327a984708SDavid Chisnall 50337a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _Compare> 50347a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50357a984708SDavid Chisnallbool 50367a984708SDavid Chisnallincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 50377a984708SDavid Chisnall _Compare __comp) 50387a984708SDavid Chisnall{ 50397a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 50407a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 50417a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 50427a984708SDavid Chisnall return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 50437a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 50447a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 50457a984708SDavid Chisnall return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 50467a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 50477a984708SDavid Chisnall} 50487a984708SDavid Chisnall 50497a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 50507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50517a984708SDavid Chisnallbool 50527a984708SDavid Chisnallincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) 50537a984708SDavid Chisnall{ 50547a984708SDavid Chisnall return _VSTD::includes(__first1, __last1, __first2, __last2, 50557a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 50567a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 50577a984708SDavid Chisnall} 50587a984708SDavid Chisnall 50597a984708SDavid Chisnall// set_union 50607a984708SDavid Chisnall 50617a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 50627a984708SDavid Chisnall_OutputIterator 50637a984708SDavid Chisnall__set_union(_InputIterator1 __first1, _InputIterator1 __last1, 50647a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 50657a984708SDavid Chisnall{ 50667a984708SDavid Chisnall for (; __first1 != __last1; ++__result) 50677a984708SDavid Chisnall { 50687a984708SDavid Chisnall if (__first2 == __last2) 50697a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 50707a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 50717a984708SDavid Chisnall { 50727a984708SDavid Chisnall *__result = *__first2; 50737a984708SDavid Chisnall ++__first2; 50747a984708SDavid Chisnall } 50757a984708SDavid Chisnall else 50767a984708SDavid Chisnall { 50777a984708SDavid Chisnall *__result = *__first1; 50787a984708SDavid Chisnall if (!__comp(*__first1, *__first2)) 50797a984708SDavid Chisnall ++__first2; 50807a984708SDavid Chisnall ++__first1; 50817a984708SDavid Chisnall } 50827a984708SDavid Chisnall } 50837a984708SDavid Chisnall return _VSTD::copy(__first2, __last2, __result); 50847a984708SDavid Chisnall} 50857a984708SDavid Chisnall 50867a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 50877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 50887a984708SDavid Chisnall_OutputIterator 50897a984708SDavid Chisnallset_union(_InputIterator1 __first1, _InputIterator1 __last1, 50907a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 50917a984708SDavid Chisnall{ 50927a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 50937a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 50947a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 50957a984708SDavid Chisnall return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 50967a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 50977a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 50987a984708SDavid Chisnall return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 50997a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 51007a984708SDavid Chisnall} 51017a984708SDavid Chisnall 51027a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 51037a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51047a984708SDavid Chisnall_OutputIterator 51057a984708SDavid Chisnallset_union(_InputIterator1 __first1, _InputIterator1 __last1, 51067a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 51077a984708SDavid Chisnall{ 51087a984708SDavid Chisnall return _VSTD::set_union(__first1, __last1, __first2, __last2, __result, 51097a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 51107a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 51117a984708SDavid Chisnall} 51127a984708SDavid Chisnall 51137a984708SDavid Chisnall// set_intersection 51147a984708SDavid Chisnall 51157a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 51167a984708SDavid Chisnall_OutputIterator 51177a984708SDavid Chisnall__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 51187a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 51197a984708SDavid Chisnall{ 51207a984708SDavid Chisnall while (__first1 != __last1 && __first2 != __last2) 51217a984708SDavid Chisnall { 51227a984708SDavid Chisnall if (__comp(*__first1, *__first2)) 51237a984708SDavid Chisnall ++__first1; 51247a984708SDavid Chisnall else 51257a984708SDavid Chisnall { 51267a984708SDavid Chisnall if (!__comp(*__first2, *__first1)) 51277a984708SDavid Chisnall { 51287a984708SDavid Chisnall *__result = *__first1; 51297a984708SDavid Chisnall ++__result; 51307a984708SDavid Chisnall ++__first1; 51317a984708SDavid Chisnall } 51327a984708SDavid Chisnall ++__first2; 51337a984708SDavid Chisnall } 51347a984708SDavid Chisnall } 51357a984708SDavid Chisnall return __result; 51367a984708SDavid Chisnall} 51377a984708SDavid Chisnall 51387a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 51397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51407a984708SDavid Chisnall_OutputIterator 51417a984708SDavid Chisnallset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 51427a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 51437a984708SDavid Chisnall{ 51447a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 51457a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 51467a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 51477a984708SDavid Chisnall return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 51487a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 51497a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 51507a984708SDavid Chisnall return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 51517a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 51527a984708SDavid Chisnall} 51537a984708SDavid Chisnall 51547a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 51557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51567a984708SDavid Chisnall_OutputIterator 51577a984708SDavid Chisnallset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 51587a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 51597a984708SDavid Chisnall{ 51607a984708SDavid Chisnall return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result, 51617a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 51627a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 51637a984708SDavid Chisnall} 51647a984708SDavid Chisnall 51657a984708SDavid Chisnall// set_difference 51667a984708SDavid Chisnall 51677a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 51687a984708SDavid Chisnall_OutputIterator 51697a984708SDavid Chisnall__set_difference(_InputIterator1 __first1, _InputIterator1 __last1, 51707a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 51717a984708SDavid Chisnall{ 51727a984708SDavid Chisnall while (__first1 != __last1) 51737a984708SDavid Chisnall { 51747a984708SDavid Chisnall if (__first2 == __last2) 51757a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 51767a984708SDavid Chisnall if (__comp(*__first1, *__first2)) 51777a984708SDavid Chisnall { 51787a984708SDavid Chisnall *__result = *__first1; 51797a984708SDavid Chisnall ++__result; 51807a984708SDavid Chisnall ++__first1; 51817a984708SDavid Chisnall } 51827a984708SDavid Chisnall else 51837a984708SDavid Chisnall { 51847a984708SDavid Chisnall if (!__comp(*__first2, *__first1)) 51857a984708SDavid Chisnall ++__first1; 51867a984708SDavid Chisnall ++__first2; 51877a984708SDavid Chisnall } 51887a984708SDavid Chisnall } 51897a984708SDavid Chisnall return __result; 51907a984708SDavid Chisnall} 51917a984708SDavid Chisnall 51927a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 51937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 51947a984708SDavid Chisnall_OutputIterator 51957a984708SDavid Chisnallset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 51967a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 51977a984708SDavid Chisnall{ 51987a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 51997a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 52007a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 52017a984708SDavid Chisnall return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 52027a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 52037a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 52047a984708SDavid Chisnall return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 52057a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 52067a984708SDavid Chisnall} 52077a984708SDavid Chisnall 52087a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 52097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 52107a984708SDavid Chisnall_OutputIterator 52117a984708SDavid Chisnallset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 52127a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 52137a984708SDavid Chisnall{ 52147a984708SDavid Chisnall return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result, 52157a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 52167a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 52177a984708SDavid Chisnall} 52187a984708SDavid Chisnall 52197a984708SDavid Chisnall// set_symmetric_difference 52207a984708SDavid Chisnall 52217a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 52227a984708SDavid Chisnall_OutputIterator 52237a984708SDavid Chisnall__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 52247a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 52257a984708SDavid Chisnall{ 52267a984708SDavid Chisnall while (__first1 != __last1) 52277a984708SDavid Chisnall { 52287a984708SDavid Chisnall if (__first2 == __last2) 52297a984708SDavid Chisnall return _VSTD::copy(__first1, __last1, __result); 52307a984708SDavid Chisnall if (__comp(*__first1, *__first2)) 52317a984708SDavid Chisnall { 52327a984708SDavid Chisnall *__result = *__first1; 52337a984708SDavid Chisnall ++__result; 52347a984708SDavid Chisnall ++__first1; 52357a984708SDavid Chisnall } 52367a984708SDavid Chisnall else 52377a984708SDavid Chisnall { 52387a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 52397a984708SDavid Chisnall { 52407a984708SDavid Chisnall *__result = *__first2; 52417a984708SDavid Chisnall ++__result; 52427a984708SDavid Chisnall } 52437a984708SDavid Chisnall else 52447a984708SDavid Chisnall ++__first1; 52457a984708SDavid Chisnall ++__first2; 52467a984708SDavid Chisnall } 52477a984708SDavid Chisnall } 52487a984708SDavid Chisnall return _VSTD::copy(__first2, __last2, __result); 52497a984708SDavid Chisnall} 52507a984708SDavid Chisnall 52517a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 52527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 52537a984708SDavid Chisnall_OutputIterator 52547a984708SDavid Chisnallset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 52557a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 52567a984708SDavid Chisnall{ 52577a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 52587a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 52597a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 52607a984708SDavid Chisnall return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 52617a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 52627a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 52637a984708SDavid Chisnall return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 52647a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 52657a984708SDavid Chisnall} 52667a984708SDavid Chisnall 52677a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 52687a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 52697a984708SDavid Chisnall_OutputIterator 52707a984708SDavid Chisnallset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 52717a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 52727a984708SDavid Chisnall{ 52737a984708SDavid Chisnall return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, 52747a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 52757a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 52767a984708SDavid Chisnall} 52777a984708SDavid Chisnall 52787a984708SDavid Chisnall// lexicographical_compare 52797a984708SDavid Chisnall 52807a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2> 52817a984708SDavid Chisnallbool 52827a984708SDavid Chisnall__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 52837a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 52847a984708SDavid Chisnall{ 52857a984708SDavid Chisnall for (; __first2 != __last2; ++__first1, ++__first2) 52867a984708SDavid Chisnall { 52877a984708SDavid Chisnall if (__first1 == __last1 || __comp(*__first1, *__first2)) 52887a984708SDavid Chisnall return true; 52897a984708SDavid Chisnall if (__comp(*__first2, *__first1)) 52907a984708SDavid Chisnall return false; 52917a984708SDavid Chisnall } 52927a984708SDavid Chisnall return false; 52937a984708SDavid Chisnall} 52947a984708SDavid Chisnall 52957a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _Compare> 52967a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 52977a984708SDavid Chisnallbool 52987a984708SDavid Chisnalllexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 52997a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 53007a984708SDavid Chisnall{ 53017a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 53027a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 53037a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 53047a984708SDavid Chisnall return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 53057a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 53067a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 53077a984708SDavid Chisnall return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 53087a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 53097a984708SDavid Chisnall} 53107a984708SDavid Chisnall 53117a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2> 53127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 53137a984708SDavid Chisnallbool 53147a984708SDavid Chisnalllexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 53157a984708SDavid Chisnall _InputIterator2 __first2, _InputIterator2 __last2) 53167a984708SDavid Chisnall{ 53177a984708SDavid Chisnall return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2, 53187a984708SDavid Chisnall __less<typename iterator_traits<_InputIterator1>::value_type, 53197a984708SDavid Chisnall typename iterator_traits<_InputIterator2>::value_type>()); 53207a984708SDavid Chisnall} 53217a984708SDavid Chisnall 53227a984708SDavid Chisnall// next_permutation 53237a984708SDavid Chisnall 53247a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 53257a984708SDavid Chisnallbool 53267a984708SDavid Chisnall__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 53277a984708SDavid Chisnall{ 53287a984708SDavid Chisnall _BidirectionalIterator __i = __last; 53297a984708SDavid Chisnall if (__first == __last || __first == --__i) 53307a984708SDavid Chisnall return false; 53317a984708SDavid Chisnall while (true) 53327a984708SDavid Chisnall { 53337a984708SDavid Chisnall _BidirectionalIterator __ip1 = __i; 53347a984708SDavid Chisnall if (__comp(*--__i, *__ip1)) 53357a984708SDavid Chisnall { 53367a984708SDavid Chisnall _BidirectionalIterator __j = __last; 53377a984708SDavid Chisnall while (!__comp(*__i, *--__j)) 53387a984708SDavid Chisnall ; 53397a984708SDavid Chisnall swap(*__i, *__j); 53407a984708SDavid Chisnall _VSTD::reverse(__ip1, __last); 53417a984708SDavid Chisnall return true; 53427a984708SDavid Chisnall } 53437a984708SDavid Chisnall if (__i == __first) 53447a984708SDavid Chisnall { 53457a984708SDavid Chisnall _VSTD::reverse(__first, __last); 53467a984708SDavid Chisnall return false; 53477a984708SDavid Chisnall } 53487a984708SDavid Chisnall } 53497a984708SDavid Chisnall} 53507a984708SDavid Chisnall 53517a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare> 53527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 53537a984708SDavid Chisnallbool 53547a984708SDavid Chisnallnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 53557a984708SDavid Chisnall{ 53567a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 53577a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 53587a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 53597a984708SDavid Chisnall return __next_permutation<_Comp_ref>(__first, __last, __c); 53607a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 53617a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 53627a984708SDavid Chisnall return __next_permutation<_Comp_ref>(__first, __last, __comp); 53637a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 53647a984708SDavid Chisnall} 53657a984708SDavid Chisnall 53667a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 53677a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 53687a984708SDavid Chisnallbool 53697a984708SDavid Chisnallnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 53707a984708SDavid Chisnall{ 53717a984708SDavid Chisnall return _VSTD::next_permutation(__first, __last, 53727a984708SDavid Chisnall __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 53737a984708SDavid Chisnall} 53747a984708SDavid Chisnall 53757a984708SDavid Chisnall// prev_permutation 53767a984708SDavid Chisnall 53777a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator> 53787a984708SDavid Chisnallbool 53797a984708SDavid Chisnall__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 53807a984708SDavid Chisnall{ 53817a984708SDavid Chisnall _BidirectionalIterator __i = __last; 53827a984708SDavid Chisnall if (__first == __last || __first == --__i) 53837a984708SDavid Chisnall return false; 53847a984708SDavid Chisnall while (true) 53857a984708SDavid Chisnall { 53867a984708SDavid Chisnall _BidirectionalIterator __ip1 = __i; 53877a984708SDavid Chisnall if (__comp(*__ip1, *--__i)) 53887a984708SDavid Chisnall { 53897a984708SDavid Chisnall _BidirectionalIterator __j = __last; 53907a984708SDavid Chisnall while (!__comp(*--__j, *__i)) 53917a984708SDavid Chisnall ; 53927a984708SDavid Chisnall swap(*__i, *__j); 53937a984708SDavid Chisnall _VSTD::reverse(__ip1, __last); 53947a984708SDavid Chisnall return true; 53957a984708SDavid Chisnall } 53967a984708SDavid Chisnall if (__i == __first) 53977a984708SDavid Chisnall { 53987a984708SDavid Chisnall _VSTD::reverse(__first, __last); 53997a984708SDavid Chisnall return false; 54007a984708SDavid Chisnall } 54017a984708SDavid Chisnall } 54027a984708SDavid Chisnall} 54037a984708SDavid Chisnall 54047a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare> 54057a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54067a984708SDavid Chisnallbool 54077a984708SDavid Chisnallprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 54087a984708SDavid Chisnall{ 54097a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2 54107a984708SDavid Chisnall typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 54117a984708SDavid Chisnall __debug_less<_Compare> __c(__comp); 54127a984708SDavid Chisnall return __prev_permutation<_Comp_ref>(__first, __last, __c); 54137a984708SDavid Chisnall#else // _LIBCPP_DEBUG2 54147a984708SDavid Chisnall typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 54157a984708SDavid Chisnall return __prev_permutation<_Comp_ref>(__first, __last, __comp); 54167a984708SDavid Chisnall#endif // _LIBCPP_DEBUG2 54177a984708SDavid Chisnall} 54187a984708SDavid Chisnall 54197a984708SDavid Chisnalltemplate <class _BidirectionalIterator> 54207a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54217a984708SDavid Chisnallbool 54227a984708SDavid Chisnallprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 54237a984708SDavid Chisnall{ 54247a984708SDavid Chisnall return _VSTD::prev_permutation(__first, __last, 54257a984708SDavid Chisnall __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 54267a984708SDavid Chisnall} 54277a984708SDavid Chisnall 54287a984708SDavid Chisnalltemplate <class _Tp> 54297a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54307a984708SDavid Chisnalltypename enable_if 54317a984708SDavid Chisnall< 54327a984708SDavid Chisnall is_integral<_Tp>::value, 54337a984708SDavid Chisnall _Tp 54347a984708SDavid Chisnall>::type 54357a984708SDavid Chisnall__rotate_left(_Tp __t, _Tp __n = 1) 54367a984708SDavid Chisnall{ 54377a984708SDavid Chisnall const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1); 54387a984708SDavid Chisnall __n &= __bits; 54397a984708SDavid Chisnall return static_cast<_Tp>((__t << __n) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> (__bits - __n))); 54407a984708SDavid Chisnall} 54417a984708SDavid Chisnall 54427a984708SDavid Chisnalltemplate <class _Tp> 54437a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY 54447a984708SDavid Chisnalltypename enable_if 54457a984708SDavid Chisnall< 54467a984708SDavid Chisnall is_integral<_Tp>::value, 54477a984708SDavid Chisnall _Tp 54487a984708SDavid Chisnall>::type 54497a984708SDavid Chisnall__rotate_right(_Tp __t, _Tp __n = 1) 54507a984708SDavid Chisnall{ 54517a984708SDavid Chisnall const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1); 54527a984708SDavid Chisnall __n &= __bits; 54537a984708SDavid Chisnall return static_cast<_Tp>((__t << (__bits - __n)) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> __n)); 54547a984708SDavid Chisnall} 54557a984708SDavid Chisnall 54567a984708SDavid Chisnall_LIBCPP_END_NAMESPACE_STD 54577a984708SDavid Chisnall 54587a984708SDavid Chisnall#endif // _LIBCPP_ALGORITHM 5459