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