1*4684ddb6SLionel Sambuc// -*- C++ -*- 2*4684ddb6SLionel Sambuc//===-------------------------- algorithm ---------------------------------===// 3*4684ddb6SLionel Sambuc// 4*4684ddb6SLionel Sambuc// The LLVM Compiler Infrastructure 5*4684ddb6SLionel Sambuc// 6*4684ddb6SLionel Sambuc// This file is dual licensed under the MIT and the University of Illinois Open 7*4684ddb6SLionel Sambuc// Source Licenses. See LICENSE.TXT for details. 8*4684ddb6SLionel Sambuc// 9*4684ddb6SLionel Sambuc//===----------------------------------------------------------------------===// 10*4684ddb6SLionel Sambuc 11*4684ddb6SLionel Sambuc#ifndef _LIBCPP_ALGORITHM 12*4684ddb6SLionel Sambuc#define _LIBCPP_ALGORITHM 13*4684ddb6SLionel Sambuc 14*4684ddb6SLionel Sambuc/* 15*4684ddb6SLionel Sambuc algorithm synopsis 16*4684ddb6SLionel Sambuc 17*4684ddb6SLionel Sambuc#include <initializer_list> 18*4684ddb6SLionel Sambuc 19*4684ddb6SLionel Sambucnamespace std 20*4684ddb6SLionel Sambuc{ 21*4684ddb6SLionel Sambuc 22*4684ddb6SLionel Sambuctemplate <class InputIterator, class Predicate> 23*4684ddb6SLionel Sambuc bool 24*4684ddb6SLionel Sambuc all_of(InputIterator first, InputIterator last, Predicate pred); 25*4684ddb6SLionel Sambuc 26*4684ddb6SLionel Sambuctemplate <class InputIterator, class Predicate> 27*4684ddb6SLionel Sambuc bool 28*4684ddb6SLionel Sambuc any_of(InputIterator first, InputIterator last, Predicate pred); 29*4684ddb6SLionel Sambuc 30*4684ddb6SLionel Sambuctemplate <class InputIterator, class Predicate> 31*4684ddb6SLionel Sambuc bool 32*4684ddb6SLionel Sambuc none_of(InputIterator first, InputIterator last, Predicate pred); 33*4684ddb6SLionel Sambuc 34*4684ddb6SLionel Sambuctemplate <class InputIterator, class Function> 35*4684ddb6SLionel Sambuc Function 36*4684ddb6SLionel Sambuc for_each(InputIterator first, InputIterator last, Function f); 37*4684ddb6SLionel Sambuc 38*4684ddb6SLionel Sambuctemplate <class InputIterator, class T> 39*4684ddb6SLionel Sambuc InputIterator 40*4684ddb6SLionel Sambuc find(InputIterator first, InputIterator last, const T& value); 41*4684ddb6SLionel Sambuc 42*4684ddb6SLionel Sambuctemplate <class InputIterator, class Predicate> 43*4684ddb6SLionel Sambuc InputIterator 44*4684ddb6SLionel Sambuc find_if(InputIterator first, InputIterator last, Predicate pred); 45*4684ddb6SLionel Sambuc 46*4684ddb6SLionel Sambuctemplate<class InputIterator, class Predicate> 47*4684ddb6SLionel Sambuc InputIterator 48*4684ddb6SLionel Sambuc find_if_not(InputIterator first, InputIterator last, Predicate pred); 49*4684ddb6SLionel Sambuc 50*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2> 51*4684ddb6SLionel Sambuc ForwardIterator1 52*4684ddb6SLionel Sambuc find_end(ForwardIterator1 first1, ForwardIterator1 last1, 53*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2); 54*4684ddb6SLionel Sambuc 55*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 56*4684ddb6SLionel Sambuc ForwardIterator1 57*4684ddb6SLionel Sambuc find_end(ForwardIterator1 first1, ForwardIterator1 last1, 58*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 59*4684ddb6SLionel Sambuc 60*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2> 61*4684ddb6SLionel Sambuc ForwardIterator1 62*4684ddb6SLionel Sambuc find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 63*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2); 64*4684ddb6SLionel Sambuc 65*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 66*4684ddb6SLionel Sambuc ForwardIterator1 67*4684ddb6SLionel Sambuc find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 68*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 69*4684ddb6SLionel Sambuc 70*4684ddb6SLionel Sambuctemplate <class ForwardIterator> 71*4684ddb6SLionel Sambuc ForwardIterator 72*4684ddb6SLionel Sambuc adjacent_find(ForwardIterator first, ForwardIterator last); 73*4684ddb6SLionel Sambuc 74*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class BinaryPredicate> 75*4684ddb6SLionel Sambuc ForwardIterator 76*4684ddb6SLionel Sambuc adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 77*4684ddb6SLionel Sambuc 78*4684ddb6SLionel Sambuctemplate <class InputIterator, class T> 79*4684ddb6SLionel Sambuc typename iterator_traits<InputIterator>::difference_type 80*4684ddb6SLionel Sambuc count(InputIterator first, InputIterator last, const T& value); 81*4684ddb6SLionel Sambuc 82*4684ddb6SLionel Sambuctemplate <class InputIterator, class Predicate> 83*4684ddb6SLionel Sambuc typename iterator_traits<InputIterator>::difference_type 84*4684ddb6SLionel Sambuc count_if(InputIterator first, InputIterator last, Predicate pred); 85*4684ddb6SLionel Sambuc 86*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2> 87*4684ddb6SLionel Sambuc pair<InputIterator1, InputIterator2> 88*4684ddb6SLionel Sambuc mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 89*4684ddb6SLionel Sambuc 90*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2> 91*4684ddb6SLionel Sambuc pair<InputIterator1, InputIterator2> 92*4684ddb6SLionel Sambuc mismatch(InputIterator1 first1, InputIterator1 last1, 93*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2); // **C++14** 94*4684ddb6SLionel Sambuc 95*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 96*4684ddb6SLionel Sambuc pair<InputIterator1, InputIterator2> 97*4684ddb6SLionel Sambuc mismatch(InputIterator1 first1, InputIterator1 last1, 98*4684ddb6SLionel Sambuc InputIterator2 first2, BinaryPredicate pred); 99*4684ddb6SLionel Sambuc 100*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 101*4684ddb6SLionel Sambuc pair<InputIterator1, InputIterator2> 102*4684ddb6SLionel Sambuc mismatch(InputIterator1 first1, InputIterator1 last1, 103*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, 104*4684ddb6SLionel Sambuc BinaryPredicate pred); // **C++14** 105*4684ddb6SLionel Sambuc 106*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2> 107*4684ddb6SLionel Sambuc bool 108*4684ddb6SLionel Sambuc equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 109*4684ddb6SLionel Sambuc 110*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2> 111*4684ddb6SLionel Sambuc bool 112*4684ddb6SLionel Sambuc equal(InputIterator1 first1, InputIterator1 last1, 113*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2); // **C++14** 114*4684ddb6SLionel Sambuc 115*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 116*4684ddb6SLionel Sambuc bool 117*4684ddb6SLionel Sambuc equal(InputIterator1 first1, InputIterator1 last1, 118*4684ddb6SLionel Sambuc InputIterator2 first2, BinaryPredicate pred); 119*4684ddb6SLionel Sambuc 120*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 121*4684ddb6SLionel Sambuc bool 122*4684ddb6SLionel Sambuc equal(InputIterator1 first1, InputIterator1 last1, 123*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, 124*4684ddb6SLionel Sambuc BinaryPredicate pred); // **C++14** 125*4684ddb6SLionel Sambuc 126*4684ddb6SLionel Sambuctemplate<class ForwardIterator1, class ForwardIterator2> 127*4684ddb6SLionel Sambuc bool 128*4684ddb6SLionel Sambuc is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 129*4684ddb6SLionel Sambuc ForwardIterator2 first2); 130*4684ddb6SLionel Sambuc 131*4684ddb6SLionel Sambuctemplate<class ForwardIterator1, class ForwardIterator2> 132*4684ddb6SLionel Sambuc bool 133*4684ddb6SLionel Sambuc is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 134*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2); // **C++14** 135*4684ddb6SLionel Sambuc 136*4684ddb6SLionel Sambuctemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 137*4684ddb6SLionel Sambuc bool 138*4684ddb6SLionel Sambuc is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 139*4684ddb6SLionel Sambuc ForwardIterator2 first2, BinaryPredicate pred); 140*4684ddb6SLionel Sambuc 141*4684ddb6SLionel Sambuctemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 142*4684ddb6SLionel Sambuc bool 143*4684ddb6SLionel Sambuc is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 144*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2, 145*4684ddb6SLionel Sambuc BinaryPredicate pred); // **C++14** 146*4684ddb6SLionel Sambuc 147*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2> 148*4684ddb6SLionel Sambuc ForwardIterator1 149*4684ddb6SLionel Sambuc search(ForwardIterator1 first1, ForwardIterator1 last1, 150*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2); 151*4684ddb6SLionel Sambuc 152*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 153*4684ddb6SLionel Sambuc ForwardIterator1 154*4684ddb6SLionel Sambuc search(ForwardIterator1 first1, ForwardIterator1 last1, 155*4684ddb6SLionel Sambuc ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 156*4684ddb6SLionel Sambuc 157*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Size, class T> 158*4684ddb6SLionel Sambuc ForwardIterator 159*4684ddb6SLionel Sambuc search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); 160*4684ddb6SLionel Sambuc 161*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Size, class T, class BinaryPredicate> 162*4684ddb6SLionel Sambuc ForwardIterator 163*4684ddb6SLionel Sambuc search_n(ForwardIterator first, ForwardIterator last, 164*4684ddb6SLionel Sambuc Size count, const T& value, BinaryPredicate pred); 165*4684ddb6SLionel Sambuc 166*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator> 167*4684ddb6SLionel Sambuc OutputIterator 168*4684ddb6SLionel Sambuc copy(InputIterator first, InputIterator last, OutputIterator result); 169*4684ddb6SLionel Sambuc 170*4684ddb6SLionel Sambuctemplate<class InputIterator, class OutputIterator, class Predicate> 171*4684ddb6SLionel Sambuc OutputIterator 172*4684ddb6SLionel Sambuc copy_if(InputIterator first, InputIterator last, 173*4684ddb6SLionel Sambuc OutputIterator result, Predicate pred); 174*4684ddb6SLionel Sambuc 175*4684ddb6SLionel Sambuctemplate<class InputIterator, class Size, class OutputIterator> 176*4684ddb6SLionel Sambuc OutputIterator 177*4684ddb6SLionel Sambuc copy_n(InputIterator first, Size n, OutputIterator result); 178*4684ddb6SLionel Sambuc 179*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator1, class BidirectionalIterator2> 180*4684ddb6SLionel Sambuc BidirectionalIterator2 181*4684ddb6SLionel Sambuc copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 182*4684ddb6SLionel Sambuc BidirectionalIterator2 result); 183*4684ddb6SLionel Sambuc 184*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2> 185*4684ddb6SLionel Sambuc ForwardIterator2 186*4684ddb6SLionel Sambuc swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); 187*4684ddb6SLionel Sambuc 188*4684ddb6SLionel Sambuctemplate <class ForwardIterator1, class ForwardIterator2> 189*4684ddb6SLionel Sambuc void 190*4684ddb6SLionel Sambuc iter_swap(ForwardIterator1 a, ForwardIterator2 b); 191*4684ddb6SLionel Sambuc 192*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator, class UnaryOperation> 193*4684ddb6SLionel Sambuc OutputIterator 194*4684ddb6SLionel Sambuc transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); 195*4684ddb6SLionel Sambuc 196*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> 197*4684ddb6SLionel Sambuc OutputIterator 198*4684ddb6SLionel Sambuc transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, 199*4684ddb6SLionel Sambuc OutputIterator result, BinaryOperation binary_op); 200*4684ddb6SLionel Sambuc 201*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 202*4684ddb6SLionel Sambuc void 203*4684ddb6SLionel Sambuc replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); 204*4684ddb6SLionel Sambuc 205*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Predicate, class T> 206*4684ddb6SLionel Sambuc void 207*4684ddb6SLionel Sambuc replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); 208*4684ddb6SLionel Sambuc 209*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator, class T> 210*4684ddb6SLionel Sambuc OutputIterator 211*4684ddb6SLionel Sambuc replace_copy(InputIterator first, InputIterator last, OutputIterator result, 212*4684ddb6SLionel Sambuc const T& old_value, const T& new_value); 213*4684ddb6SLionel Sambuc 214*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator, class Predicate, class T> 215*4684ddb6SLionel Sambuc OutputIterator 216*4684ddb6SLionel Sambuc replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value); 217*4684ddb6SLionel Sambuc 218*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 219*4684ddb6SLionel Sambuc void 220*4684ddb6SLionel Sambuc fill(ForwardIterator first, ForwardIterator last, const T& value); 221*4684ddb6SLionel Sambuc 222*4684ddb6SLionel Sambuctemplate <class OutputIterator, class Size, class T> 223*4684ddb6SLionel Sambuc OutputIterator 224*4684ddb6SLionel Sambuc fill_n(OutputIterator first, Size n, const T& value); 225*4684ddb6SLionel Sambuc 226*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Generator> 227*4684ddb6SLionel Sambuc void 228*4684ddb6SLionel Sambuc generate(ForwardIterator first, ForwardIterator last, Generator gen); 229*4684ddb6SLionel Sambuc 230*4684ddb6SLionel Sambuctemplate <class OutputIterator, class Size, class Generator> 231*4684ddb6SLionel Sambuc OutputIterator 232*4684ddb6SLionel Sambuc generate_n(OutputIterator first, Size n, Generator gen); 233*4684ddb6SLionel Sambuc 234*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 235*4684ddb6SLionel Sambuc ForwardIterator 236*4684ddb6SLionel Sambuc remove(ForwardIterator first, ForwardIterator last, const T& value); 237*4684ddb6SLionel Sambuc 238*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Predicate> 239*4684ddb6SLionel Sambuc ForwardIterator 240*4684ddb6SLionel Sambuc remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); 241*4684ddb6SLionel Sambuc 242*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator, class T> 243*4684ddb6SLionel Sambuc OutputIterator 244*4684ddb6SLionel Sambuc remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); 245*4684ddb6SLionel Sambuc 246*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator, class Predicate> 247*4684ddb6SLionel Sambuc OutputIterator 248*4684ddb6SLionel Sambuc remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); 249*4684ddb6SLionel Sambuc 250*4684ddb6SLionel Sambuctemplate <class ForwardIterator> 251*4684ddb6SLionel Sambuc ForwardIterator 252*4684ddb6SLionel Sambuc unique(ForwardIterator first, ForwardIterator last); 253*4684ddb6SLionel Sambuc 254*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class BinaryPredicate> 255*4684ddb6SLionel Sambuc ForwardIterator 256*4684ddb6SLionel Sambuc unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 257*4684ddb6SLionel Sambuc 258*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator> 259*4684ddb6SLionel Sambuc OutputIterator 260*4684ddb6SLionel Sambuc unique_copy(InputIterator first, InputIterator last, OutputIterator result); 261*4684ddb6SLionel Sambuc 262*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator, class BinaryPredicate> 263*4684ddb6SLionel Sambuc OutputIterator 264*4684ddb6SLionel Sambuc unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); 265*4684ddb6SLionel Sambuc 266*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator> 267*4684ddb6SLionel Sambuc void 268*4684ddb6SLionel Sambuc reverse(BidirectionalIterator first, BidirectionalIterator last); 269*4684ddb6SLionel Sambuc 270*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator, class OutputIterator> 271*4684ddb6SLionel Sambuc OutputIterator 272*4684ddb6SLionel Sambuc reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); 273*4684ddb6SLionel Sambuc 274*4684ddb6SLionel Sambuctemplate <class ForwardIterator> 275*4684ddb6SLionel Sambuc ForwardIterator 276*4684ddb6SLionel Sambuc rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); 277*4684ddb6SLionel Sambuc 278*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class OutputIterator> 279*4684ddb6SLionel Sambuc OutputIterator 280*4684ddb6SLionel Sambuc rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); 281*4684ddb6SLionel Sambuc 282*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 283*4684ddb6SLionel Sambuc void 284*4684ddb6SLionel Sambuc random_shuffle(RandomAccessIterator first, RandomAccessIterator last); 285*4684ddb6SLionel Sambuc 286*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class RandomNumberGenerator> 287*4684ddb6SLionel Sambuc void 288*4684ddb6SLionel Sambuc random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand); 289*4684ddb6SLionel Sambuc 290*4684ddb6SLionel Sambuctemplate<class RandomAccessIterator, class UniformRandomNumberGenerator> 291*4684ddb6SLionel Sambuc void shuffle(RandomAccessIterator first, RandomAccessIterator last, 292*4684ddb6SLionel Sambuc UniformRandomNumberGenerator&& g); 293*4684ddb6SLionel Sambuc 294*4684ddb6SLionel Sambuctemplate <class InputIterator, class Predicate> 295*4684ddb6SLionel Sambuc bool 296*4684ddb6SLionel Sambuc is_partitioned(InputIterator first, InputIterator last, Predicate pred); 297*4684ddb6SLionel Sambuc 298*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Predicate> 299*4684ddb6SLionel Sambuc ForwardIterator 300*4684ddb6SLionel Sambuc partition(ForwardIterator first, ForwardIterator last, Predicate pred); 301*4684ddb6SLionel Sambuc 302*4684ddb6SLionel Sambuctemplate <class InputIterator, class OutputIterator1, 303*4684ddb6SLionel Sambuc class OutputIterator2, class Predicate> 304*4684ddb6SLionel Sambuc pair<OutputIterator1, OutputIterator2> 305*4684ddb6SLionel Sambuc partition_copy(InputIterator first, InputIterator last, 306*4684ddb6SLionel Sambuc OutputIterator1 out_true, OutputIterator2 out_false, 307*4684ddb6SLionel Sambuc Predicate pred); 308*4684ddb6SLionel Sambuc 309*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Predicate> 310*4684ddb6SLionel Sambuc ForwardIterator 311*4684ddb6SLionel Sambuc stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred); 312*4684ddb6SLionel Sambuc 313*4684ddb6SLionel Sambuctemplate<class ForwardIterator, class Predicate> 314*4684ddb6SLionel Sambuc ForwardIterator 315*4684ddb6SLionel Sambuc partition_point(ForwardIterator first, ForwardIterator last, Predicate pred); 316*4684ddb6SLionel Sambuc 317*4684ddb6SLionel Sambuctemplate <class ForwardIterator> 318*4684ddb6SLionel Sambuc bool 319*4684ddb6SLionel Sambuc is_sorted(ForwardIterator first, ForwardIterator last); 320*4684ddb6SLionel Sambuc 321*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Compare> 322*4684ddb6SLionel Sambuc bool 323*4684ddb6SLionel Sambuc is_sorted(ForwardIterator first, ForwardIterator last, Compare comp); 324*4684ddb6SLionel Sambuc 325*4684ddb6SLionel Sambuctemplate<class ForwardIterator> 326*4684ddb6SLionel Sambuc ForwardIterator 327*4684ddb6SLionel Sambuc is_sorted_until(ForwardIterator first, ForwardIterator last); 328*4684ddb6SLionel Sambuc 329*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Compare> 330*4684ddb6SLionel Sambuc ForwardIterator 331*4684ddb6SLionel Sambuc is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp); 332*4684ddb6SLionel Sambuc 333*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 334*4684ddb6SLionel Sambuc void 335*4684ddb6SLionel Sambuc sort(RandomAccessIterator first, RandomAccessIterator last); 336*4684ddb6SLionel Sambuc 337*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 338*4684ddb6SLionel Sambuc void 339*4684ddb6SLionel Sambuc sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 340*4684ddb6SLionel Sambuc 341*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 342*4684ddb6SLionel Sambuc void 343*4684ddb6SLionel Sambuc stable_sort(RandomAccessIterator first, RandomAccessIterator last); 344*4684ddb6SLionel Sambuc 345*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 346*4684ddb6SLionel Sambuc void 347*4684ddb6SLionel Sambuc stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 348*4684ddb6SLionel Sambuc 349*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 350*4684ddb6SLionel Sambuc void 351*4684ddb6SLionel Sambuc partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); 352*4684ddb6SLionel Sambuc 353*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 354*4684ddb6SLionel Sambuc void 355*4684ddb6SLionel Sambuc partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); 356*4684ddb6SLionel Sambuc 357*4684ddb6SLionel Sambuctemplate <class InputIterator, class RandomAccessIterator> 358*4684ddb6SLionel Sambuc RandomAccessIterator 359*4684ddb6SLionel Sambuc partial_sort_copy(InputIterator first, InputIterator last, 360*4684ddb6SLionel Sambuc RandomAccessIterator result_first, RandomAccessIterator result_last); 361*4684ddb6SLionel Sambuc 362*4684ddb6SLionel Sambuctemplate <class InputIterator, class RandomAccessIterator, class Compare> 363*4684ddb6SLionel Sambuc RandomAccessIterator 364*4684ddb6SLionel Sambuc partial_sort_copy(InputIterator first, InputIterator last, 365*4684ddb6SLionel Sambuc RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); 366*4684ddb6SLionel Sambuc 367*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 368*4684ddb6SLionel Sambuc void 369*4684ddb6SLionel Sambuc nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); 370*4684ddb6SLionel Sambuc 371*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 372*4684ddb6SLionel Sambuc void 373*4684ddb6SLionel Sambuc nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); 374*4684ddb6SLionel Sambuc 375*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 376*4684ddb6SLionel Sambuc ForwardIterator 377*4684ddb6SLionel Sambuc lower_bound(ForwardIterator first, ForwardIterator last, const T& value); 378*4684ddb6SLionel Sambuc 379*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T, class Compare> 380*4684ddb6SLionel Sambuc ForwardIterator 381*4684ddb6SLionel Sambuc lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 382*4684ddb6SLionel Sambuc 383*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 384*4684ddb6SLionel Sambuc ForwardIterator 385*4684ddb6SLionel Sambuc upper_bound(ForwardIterator first, ForwardIterator last, const T& value); 386*4684ddb6SLionel Sambuc 387*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T, class Compare> 388*4684ddb6SLionel Sambuc ForwardIterator 389*4684ddb6SLionel Sambuc upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 390*4684ddb6SLionel Sambuc 391*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 392*4684ddb6SLionel Sambuc pair<ForwardIterator, ForwardIterator> 393*4684ddb6SLionel Sambuc equal_range(ForwardIterator first, ForwardIterator last, const T& value); 394*4684ddb6SLionel Sambuc 395*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T, class Compare> 396*4684ddb6SLionel Sambuc pair<ForwardIterator, ForwardIterator> 397*4684ddb6SLionel Sambuc equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 398*4684ddb6SLionel Sambuc 399*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T> 400*4684ddb6SLionel Sambuc bool 401*4684ddb6SLionel Sambuc binary_search(ForwardIterator first, ForwardIterator last, const T& value); 402*4684ddb6SLionel Sambuc 403*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class T, class Compare> 404*4684ddb6SLionel Sambuc bool 405*4684ddb6SLionel Sambuc binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 406*4684ddb6SLionel Sambuc 407*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator> 408*4684ddb6SLionel Sambuc OutputIterator 409*4684ddb6SLionel Sambuc merge(InputIterator1 first1, InputIterator1 last1, 410*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result); 411*4684ddb6SLionel Sambuc 412*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 413*4684ddb6SLionel Sambuc OutputIterator 414*4684ddb6SLionel Sambuc merge(InputIterator1 first1, InputIterator1 last1, 415*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 416*4684ddb6SLionel Sambuc 417*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator> 418*4684ddb6SLionel Sambuc void 419*4684ddb6SLionel Sambuc inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); 420*4684ddb6SLionel Sambuc 421*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator, class Compare> 422*4684ddb6SLionel Sambuc void 423*4684ddb6SLionel Sambuc inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); 424*4684ddb6SLionel Sambuc 425*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2> 426*4684ddb6SLionel Sambuc bool 427*4684ddb6SLionel Sambuc includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 428*4684ddb6SLionel Sambuc 429*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class Compare> 430*4684ddb6SLionel Sambuc bool 431*4684ddb6SLionel Sambuc includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); 432*4684ddb6SLionel Sambuc 433*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator> 434*4684ddb6SLionel Sambuc OutputIterator 435*4684ddb6SLionel Sambuc set_union(InputIterator1 first1, InputIterator1 last1, 436*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result); 437*4684ddb6SLionel Sambuc 438*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 439*4684ddb6SLionel Sambuc OutputIterator 440*4684ddb6SLionel Sambuc set_union(InputIterator1 first1, InputIterator1 last1, 441*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 442*4684ddb6SLionel Sambuc 443*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator> 444*4684ddb6SLionel Sambuc OutputIterator 445*4684ddb6SLionel Sambuc set_intersection(InputIterator1 first1, InputIterator1 last1, 446*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result); 447*4684ddb6SLionel Sambuc 448*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 449*4684ddb6SLionel Sambuc OutputIterator 450*4684ddb6SLionel Sambuc set_intersection(InputIterator1 first1, InputIterator1 last1, 451*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 452*4684ddb6SLionel Sambuc 453*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator> 454*4684ddb6SLionel Sambuc OutputIterator 455*4684ddb6SLionel Sambuc set_difference(InputIterator1 first1, InputIterator1 last1, 456*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result); 457*4684ddb6SLionel Sambuc 458*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 459*4684ddb6SLionel Sambuc OutputIterator 460*4684ddb6SLionel Sambuc set_difference(InputIterator1 first1, InputIterator1 last1, 461*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 462*4684ddb6SLionel Sambuc 463*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator> 464*4684ddb6SLionel Sambuc OutputIterator 465*4684ddb6SLionel Sambuc set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 466*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result); 467*4684ddb6SLionel Sambuc 468*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 469*4684ddb6SLionel Sambuc OutputIterator 470*4684ddb6SLionel Sambuc set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 471*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 472*4684ddb6SLionel Sambuc 473*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 474*4684ddb6SLionel Sambuc void 475*4684ddb6SLionel Sambuc push_heap(RandomAccessIterator first, RandomAccessIterator last); 476*4684ddb6SLionel Sambuc 477*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 478*4684ddb6SLionel Sambuc void 479*4684ddb6SLionel Sambuc push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 480*4684ddb6SLionel Sambuc 481*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 482*4684ddb6SLionel Sambuc void 483*4684ddb6SLionel Sambuc pop_heap(RandomAccessIterator first, RandomAccessIterator last); 484*4684ddb6SLionel Sambuc 485*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 486*4684ddb6SLionel Sambuc void 487*4684ddb6SLionel Sambuc pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 488*4684ddb6SLionel Sambuc 489*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 490*4684ddb6SLionel Sambuc void 491*4684ddb6SLionel Sambuc make_heap(RandomAccessIterator first, RandomAccessIterator last); 492*4684ddb6SLionel Sambuc 493*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 494*4684ddb6SLionel Sambuc void 495*4684ddb6SLionel Sambuc make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 496*4684ddb6SLionel Sambuc 497*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 498*4684ddb6SLionel Sambuc void 499*4684ddb6SLionel Sambuc sort_heap(RandomAccessIterator first, RandomAccessIterator last); 500*4684ddb6SLionel Sambuc 501*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 502*4684ddb6SLionel Sambuc void 503*4684ddb6SLionel Sambuc sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 504*4684ddb6SLionel Sambuc 505*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 506*4684ddb6SLionel Sambuc bool 507*4684ddb6SLionel Sambuc is_heap(RandomAccessIterator first, RandomAccessiterator last); 508*4684ddb6SLionel Sambuc 509*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 510*4684ddb6SLionel Sambuc bool 511*4684ddb6SLionel Sambuc is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 512*4684ddb6SLionel Sambuc 513*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator> 514*4684ddb6SLionel Sambuc RandomAccessIterator 515*4684ddb6SLionel Sambuc is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 516*4684ddb6SLionel Sambuc 517*4684ddb6SLionel Sambuctemplate <class RandomAccessIterator, class Compare> 518*4684ddb6SLionel Sambuc RandomAccessIterator 519*4684ddb6SLionel Sambuc is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 520*4684ddb6SLionel Sambuc 521*4684ddb6SLionel Sambuctemplate <class ForwardIterator> 522*4684ddb6SLionel Sambuc ForwardIterator 523*4684ddb6SLionel Sambuc min_element(ForwardIterator first, ForwardIterator last); 524*4684ddb6SLionel Sambuc 525*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Compare> 526*4684ddb6SLionel Sambuc ForwardIterator 527*4684ddb6SLionel Sambuc min_element(ForwardIterator first, ForwardIterator last, Compare comp); 528*4684ddb6SLionel Sambuc 529*4684ddb6SLionel Sambuctemplate <class T> 530*4684ddb6SLionel Sambuc const T& 531*4684ddb6SLionel Sambuc min(const T& a, const T& b); 532*4684ddb6SLionel Sambuc 533*4684ddb6SLionel Sambuctemplate <class T, class Compare> 534*4684ddb6SLionel Sambuc const T& 535*4684ddb6SLionel Sambuc min(const T& a, const T& b, Compare comp); 536*4684ddb6SLionel Sambuc 537*4684ddb6SLionel Sambuctemplate<class T> 538*4684ddb6SLionel Sambuc T 539*4684ddb6SLionel Sambuc min(initializer_list<T> t); 540*4684ddb6SLionel Sambuc 541*4684ddb6SLionel Sambuctemplate<class T, class Compare> 542*4684ddb6SLionel Sambuc T 543*4684ddb6SLionel Sambuc min(initializer_list<T> t, Compare comp); 544*4684ddb6SLionel Sambuc 545*4684ddb6SLionel Sambuctemplate <class ForwardIterator> 546*4684ddb6SLionel Sambuc ForwardIterator 547*4684ddb6SLionel Sambuc max_element(ForwardIterator first, ForwardIterator last); 548*4684ddb6SLionel Sambuc 549*4684ddb6SLionel Sambuctemplate <class ForwardIterator, class Compare> 550*4684ddb6SLionel Sambuc ForwardIterator 551*4684ddb6SLionel Sambuc max_element(ForwardIterator first, ForwardIterator last, Compare comp); 552*4684ddb6SLionel Sambuc 553*4684ddb6SLionel Sambuctemplate <class T> 554*4684ddb6SLionel Sambuc const T& 555*4684ddb6SLionel Sambuc max(const T& a, const T& b); 556*4684ddb6SLionel Sambuc 557*4684ddb6SLionel Sambuctemplate <class T, class Compare> 558*4684ddb6SLionel Sambuc const T& 559*4684ddb6SLionel Sambuc max(const T& a, const T& b, Compare comp); 560*4684ddb6SLionel Sambuc 561*4684ddb6SLionel Sambuctemplate<class T> 562*4684ddb6SLionel Sambuc T 563*4684ddb6SLionel Sambuc max(initializer_list<T> t); 564*4684ddb6SLionel Sambuc 565*4684ddb6SLionel Sambuctemplate<class T, class Compare> 566*4684ddb6SLionel Sambuc T 567*4684ddb6SLionel Sambuc max(initializer_list<T> t, Compare comp); 568*4684ddb6SLionel Sambuc 569*4684ddb6SLionel Sambuctemplate<class ForwardIterator> 570*4684ddb6SLionel Sambuc pair<ForwardIterator, ForwardIterator> 571*4684ddb6SLionel Sambuc minmax_element(ForwardIterator first, ForwardIterator last); 572*4684ddb6SLionel Sambuc 573*4684ddb6SLionel Sambuctemplate<class ForwardIterator, class Compare> 574*4684ddb6SLionel Sambuc pair<ForwardIterator, ForwardIterator> 575*4684ddb6SLionel Sambuc minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); 576*4684ddb6SLionel Sambuc 577*4684ddb6SLionel Sambuctemplate<class T> 578*4684ddb6SLionel Sambuc pair<const T&, const T&> 579*4684ddb6SLionel Sambuc minmax(const T& a, const T& b); 580*4684ddb6SLionel Sambuc 581*4684ddb6SLionel Sambuctemplate<class T, class Compare> 582*4684ddb6SLionel Sambuc pair<const T&, const T&> 583*4684ddb6SLionel Sambuc minmax(const T& a, const T& b, Compare comp); 584*4684ddb6SLionel Sambuc 585*4684ddb6SLionel Sambuctemplate<class T> 586*4684ddb6SLionel Sambuc pair<T, T> 587*4684ddb6SLionel Sambuc minmax(initializer_list<T> t); 588*4684ddb6SLionel Sambuc 589*4684ddb6SLionel Sambuctemplate<class T, class Compare> 590*4684ddb6SLionel Sambuc pair<T, T> 591*4684ddb6SLionel Sambuc minmax(initializer_list<T> t, Compare comp); 592*4684ddb6SLionel Sambuc 593*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2> 594*4684ddb6SLionel Sambuc bool 595*4684ddb6SLionel Sambuc lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 596*4684ddb6SLionel Sambuc 597*4684ddb6SLionel Sambuctemplate <class InputIterator1, class InputIterator2, class Compare> 598*4684ddb6SLionel Sambuc bool 599*4684ddb6SLionel Sambuc lexicographical_compare(InputIterator1 first1, InputIterator1 last1, 600*4684ddb6SLionel Sambuc InputIterator2 first2, InputIterator2 last2, Compare comp); 601*4684ddb6SLionel Sambuc 602*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator> 603*4684ddb6SLionel Sambuc bool 604*4684ddb6SLionel Sambuc next_permutation(BidirectionalIterator first, BidirectionalIterator last); 605*4684ddb6SLionel Sambuc 606*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator, class Compare> 607*4684ddb6SLionel Sambuc bool 608*4684ddb6SLionel Sambuc next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 609*4684ddb6SLionel Sambuc 610*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator> 611*4684ddb6SLionel Sambuc bool 612*4684ddb6SLionel Sambuc prev_permutation(BidirectionalIterator first, BidirectionalIterator last); 613*4684ddb6SLionel Sambuc 614*4684ddb6SLionel Sambuctemplate <class BidirectionalIterator, class Compare> 615*4684ddb6SLionel Sambuc bool 616*4684ddb6SLionel Sambuc prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 617*4684ddb6SLionel Sambuc 618*4684ddb6SLionel Sambuc} // std 619*4684ddb6SLionel Sambuc 620*4684ddb6SLionel Sambuc*/ 621*4684ddb6SLionel Sambuc 622*4684ddb6SLionel Sambuc#include <__config> 623*4684ddb6SLionel Sambuc#include <initializer_list> 624*4684ddb6SLionel Sambuc#include <type_traits> 625*4684ddb6SLionel Sambuc#include <cstring> 626*4684ddb6SLionel Sambuc#include <utility> 627*4684ddb6SLionel Sambuc#include <memory> 628*4684ddb6SLionel Sambuc#include <iterator> 629*4684ddb6SLionel Sambuc#include <cstddef> 630*4684ddb6SLionel Sambuc 631*4684ddb6SLionel Sambuc#if defined(__IBMCPP__) 632*4684ddb6SLionel Sambuc#include "support/ibm/support.h" 633*4684ddb6SLionel Sambuc#endif 634*4684ddb6SLionel Sambuc#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) 635*4684ddb6SLionel Sambuc#include "support/win32/support.h" 636*4684ddb6SLionel Sambuc#endif 637*4684ddb6SLionel Sambuc 638*4684ddb6SLionel Sambuc#include <__undef_min_max> 639*4684ddb6SLionel Sambuc 640*4684ddb6SLionel Sambuc#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 641*4684ddb6SLionel Sambuc#pragma GCC system_header 642*4684ddb6SLionel Sambuc#endif 643*4684ddb6SLionel Sambuc 644*4684ddb6SLionel Sambuc_LIBCPP_BEGIN_NAMESPACE_STD 645*4684ddb6SLionel Sambuc 646*4684ddb6SLionel Sambuctemplate <class _T1, class _T2 = _T1> 647*4684ddb6SLionel Sambucstruct __equal_to 648*4684ddb6SLionel Sambuc{ 649*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 650*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;} 651*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;} 652*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;} 653*4684ddb6SLionel Sambuc}; 654*4684ddb6SLionel Sambuc 655*4684ddb6SLionel Sambuctemplate <class _T1> 656*4684ddb6SLionel Sambucstruct __equal_to<_T1, _T1> 657*4684ddb6SLionel Sambuc{ 658*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 659*4684ddb6SLionel Sambuc}; 660*4684ddb6SLionel Sambuc 661*4684ddb6SLionel Sambuctemplate <class _T1> 662*4684ddb6SLionel Sambucstruct __equal_to<const _T1, _T1> 663*4684ddb6SLionel Sambuc{ 664*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 665*4684ddb6SLionel Sambuc}; 666*4684ddb6SLionel Sambuc 667*4684ddb6SLionel Sambuctemplate <class _T1> 668*4684ddb6SLionel Sambucstruct __equal_to<_T1, const _T1> 669*4684ddb6SLionel Sambuc{ 670*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;} 671*4684ddb6SLionel Sambuc}; 672*4684ddb6SLionel Sambuc 673*4684ddb6SLionel Sambuctemplate <class _T1, class _T2 = _T1> 674*4684ddb6SLionel Sambucstruct __less 675*4684ddb6SLionel Sambuc{ 676*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 677*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;} 678*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;} 679*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;} 680*4684ddb6SLionel Sambuc}; 681*4684ddb6SLionel Sambuc 682*4684ddb6SLionel Sambuctemplate <class _T1> 683*4684ddb6SLionel Sambucstruct __less<_T1, _T1> 684*4684ddb6SLionel Sambuc{ 685*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 686*4684ddb6SLionel Sambuc}; 687*4684ddb6SLionel Sambuc 688*4684ddb6SLionel Sambuctemplate <class _T1> 689*4684ddb6SLionel Sambucstruct __less<const _T1, _T1> 690*4684ddb6SLionel Sambuc{ 691*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 692*4684ddb6SLionel Sambuc}; 693*4684ddb6SLionel Sambuc 694*4684ddb6SLionel Sambuctemplate <class _T1> 695*4684ddb6SLionel Sambucstruct __less<_T1, const _T1> 696*4684ddb6SLionel Sambuc{ 697*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;} 698*4684ddb6SLionel Sambuc}; 699*4684ddb6SLionel Sambuc 700*4684ddb6SLionel Sambuctemplate <class _Predicate> 701*4684ddb6SLionel Sambucclass __negate 702*4684ddb6SLionel Sambuc{ 703*4684ddb6SLionel Sambucprivate: 704*4684ddb6SLionel Sambuc _Predicate __p_; 705*4684ddb6SLionel Sambucpublic: 706*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY __negate() {} 707*4684ddb6SLionel Sambuc 708*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY 709*4684ddb6SLionel Sambuc explicit __negate(_Predicate __p) : __p_(__p) {} 710*4684ddb6SLionel Sambuc 711*4684ddb6SLionel Sambuc template <class _T1> 712*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY 713*4684ddb6SLionel Sambuc bool operator()(const _T1& __x) {return !__p_(__x);} 714*4684ddb6SLionel Sambuc 715*4684ddb6SLionel Sambuc template <class _T1, class _T2> 716*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY 717*4684ddb6SLionel Sambuc bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);} 718*4684ddb6SLionel Sambuc}; 719*4684ddb6SLionel Sambuc 720*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 721*4684ddb6SLionel Sambuc 722*4684ddb6SLionel Sambuctemplate <class _Compare> 723*4684ddb6SLionel Sambucstruct __debug_less 724*4684ddb6SLionel Sambuc{ 725*4684ddb6SLionel Sambuc _Compare __comp_; 726*4684ddb6SLionel Sambuc __debug_less(_Compare& __c) : __comp_(__c) {} 727*4684ddb6SLionel Sambuc template <class _Tp, class _Up> 728*4684ddb6SLionel Sambuc bool operator()(const _Tp& __x, const _Up& __y) 729*4684ddb6SLionel Sambuc { 730*4684ddb6SLionel Sambuc bool __r = __comp_(__x, __y); 731*4684ddb6SLionel Sambuc if (__r) 732*4684ddb6SLionel Sambuc _LIBCPP_ASSERT(!__comp_(__y, __x), "Comparator does not induce a strict weak ordering"); 733*4684ddb6SLionel Sambuc return __r; 734*4684ddb6SLionel Sambuc } 735*4684ddb6SLionel Sambuc}; 736*4684ddb6SLionel Sambuc 737*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 738*4684ddb6SLionel Sambuc 739*4684ddb6SLionel Sambuc// Precondition: __x != 0 740*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 741*4684ddb6SLionel Sambucunsigned 742*4684ddb6SLionel Sambuc__ctz(unsigned __x) 743*4684ddb6SLionel Sambuc{ 744*4684ddb6SLionel Sambuc return static_cast<unsigned>(__builtin_ctz(__x)); 745*4684ddb6SLionel Sambuc} 746*4684ddb6SLionel Sambuc 747*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 748*4684ddb6SLionel Sambucunsigned long 749*4684ddb6SLionel Sambuc__ctz(unsigned long __x) 750*4684ddb6SLionel Sambuc{ 751*4684ddb6SLionel Sambuc return static_cast<unsigned long>(__builtin_ctzl(__x)); 752*4684ddb6SLionel Sambuc} 753*4684ddb6SLionel Sambuc 754*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 755*4684ddb6SLionel Sambucunsigned long long 756*4684ddb6SLionel Sambuc__ctz(unsigned long long __x) 757*4684ddb6SLionel Sambuc{ 758*4684ddb6SLionel Sambuc return static_cast<unsigned long long>(__builtin_ctzll(__x)); 759*4684ddb6SLionel Sambuc} 760*4684ddb6SLionel Sambuc 761*4684ddb6SLionel Sambuc// Precondition: __x != 0 762*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 763*4684ddb6SLionel Sambucunsigned 764*4684ddb6SLionel Sambuc__clz(unsigned __x) 765*4684ddb6SLionel Sambuc{ 766*4684ddb6SLionel Sambuc return static_cast<unsigned>(__builtin_clz(__x)); 767*4684ddb6SLionel Sambuc} 768*4684ddb6SLionel Sambuc 769*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 770*4684ddb6SLionel Sambucunsigned long 771*4684ddb6SLionel Sambuc__clz(unsigned long __x) 772*4684ddb6SLionel Sambuc{ 773*4684ddb6SLionel Sambuc return static_cast<unsigned long>(__builtin_clzl (__x)); 774*4684ddb6SLionel Sambuc} 775*4684ddb6SLionel Sambuc 776*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 777*4684ddb6SLionel Sambucunsigned long long 778*4684ddb6SLionel Sambuc__clz(unsigned long long __x) 779*4684ddb6SLionel Sambuc{ 780*4684ddb6SLionel Sambuc return static_cast<unsigned long long>(__builtin_clzll(__x)); 781*4684ddb6SLionel Sambuc} 782*4684ddb6SLionel Sambuc 783*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned __x) {return __builtin_popcount (__x);} 784*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long __x) {return __builtin_popcountl (__x);} 785*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long long __x) {return __builtin_popcountll(__x);} 786*4684ddb6SLionel Sambuc 787*4684ddb6SLionel Sambuc// all_of 788*4684ddb6SLionel Sambuc 789*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Predicate> 790*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 791*4684ddb6SLionel Sambucbool 792*4684ddb6SLionel Sambucall_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 793*4684ddb6SLionel Sambuc{ 794*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 795*4684ddb6SLionel Sambuc if (!__pred(*__first)) 796*4684ddb6SLionel Sambuc return false; 797*4684ddb6SLionel Sambuc return true; 798*4684ddb6SLionel Sambuc} 799*4684ddb6SLionel Sambuc 800*4684ddb6SLionel Sambuc// any_of 801*4684ddb6SLionel Sambuc 802*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Predicate> 803*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 804*4684ddb6SLionel Sambucbool 805*4684ddb6SLionel Sambucany_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 806*4684ddb6SLionel Sambuc{ 807*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 808*4684ddb6SLionel Sambuc if (__pred(*__first)) 809*4684ddb6SLionel Sambuc return true; 810*4684ddb6SLionel Sambuc return false; 811*4684ddb6SLionel Sambuc} 812*4684ddb6SLionel Sambuc 813*4684ddb6SLionel Sambuc// none_of 814*4684ddb6SLionel Sambuc 815*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Predicate> 816*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 817*4684ddb6SLionel Sambucbool 818*4684ddb6SLionel Sambucnone_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) 819*4684ddb6SLionel Sambuc{ 820*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 821*4684ddb6SLionel Sambuc if (__pred(*__first)) 822*4684ddb6SLionel Sambuc return false; 823*4684ddb6SLionel Sambuc return true; 824*4684ddb6SLionel Sambuc} 825*4684ddb6SLionel Sambuc 826*4684ddb6SLionel Sambuc// for_each 827*4684ddb6SLionel Sambuc 828*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Function> 829*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 830*4684ddb6SLionel Sambuc_Function 831*4684ddb6SLionel Sambucfor_each(_InputIterator __first, _InputIterator __last, _Function __f) 832*4684ddb6SLionel Sambuc{ 833*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 834*4684ddb6SLionel Sambuc __f(*__first); 835*4684ddb6SLionel Sambuc return _VSTD::move(__f); // explicitly moved for (emulated) C++03 836*4684ddb6SLionel Sambuc} 837*4684ddb6SLionel Sambuc 838*4684ddb6SLionel Sambuc// find 839*4684ddb6SLionel Sambuc 840*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Tp> 841*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 842*4684ddb6SLionel Sambuc_InputIterator 843*4684ddb6SLionel Sambucfind(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 844*4684ddb6SLionel Sambuc{ 845*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 846*4684ddb6SLionel Sambuc if (*__first == __value_) 847*4684ddb6SLionel Sambuc break; 848*4684ddb6SLionel Sambuc return __first; 849*4684ddb6SLionel Sambuc} 850*4684ddb6SLionel Sambuc 851*4684ddb6SLionel Sambuc// find_if 852*4684ddb6SLionel Sambuc 853*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Predicate> 854*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 855*4684ddb6SLionel Sambuc_InputIterator 856*4684ddb6SLionel Sambucfind_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 857*4684ddb6SLionel Sambuc{ 858*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 859*4684ddb6SLionel Sambuc if (__pred(*__first)) 860*4684ddb6SLionel Sambuc break; 861*4684ddb6SLionel Sambuc return __first; 862*4684ddb6SLionel Sambuc} 863*4684ddb6SLionel Sambuc 864*4684ddb6SLionel Sambuc// find_if_not 865*4684ddb6SLionel Sambuc 866*4684ddb6SLionel Sambuctemplate<class _InputIterator, class _Predicate> 867*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 868*4684ddb6SLionel Sambuc_InputIterator 869*4684ddb6SLionel Sambucfind_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) 870*4684ddb6SLionel Sambuc{ 871*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 872*4684ddb6SLionel Sambuc if (!__pred(*__first)) 873*4684ddb6SLionel Sambuc break; 874*4684ddb6SLionel Sambuc return __first; 875*4684ddb6SLionel Sambuc} 876*4684ddb6SLionel Sambuc 877*4684ddb6SLionel Sambuc// find_end 878*4684ddb6SLionel Sambuc 879*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 880*4684ddb6SLionel Sambuc_ForwardIterator1 881*4684ddb6SLionel Sambuc__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 882*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 883*4684ddb6SLionel Sambuc forward_iterator_tag, forward_iterator_tag) 884*4684ddb6SLionel Sambuc{ 885*4684ddb6SLionel Sambuc // modeled after search algorithm 886*4684ddb6SLionel Sambuc _ForwardIterator1 __r = __last1; // __last1 is the "default" answer 887*4684ddb6SLionel Sambuc if (__first2 == __last2) 888*4684ddb6SLionel Sambuc return __r; 889*4684ddb6SLionel Sambuc while (true) 890*4684ddb6SLionel Sambuc { 891*4684ddb6SLionel Sambuc while (true) 892*4684ddb6SLionel Sambuc { 893*4684ddb6SLionel Sambuc if (__first1 == __last1) // if source exhausted return last correct answer 894*4684ddb6SLionel Sambuc return __r; // (or __last1 if never found) 895*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 896*4684ddb6SLionel Sambuc break; 897*4684ddb6SLionel Sambuc ++__first1; 898*4684ddb6SLionel Sambuc } 899*4684ddb6SLionel Sambuc // *__first1 matches *__first2, now match elements after here 900*4684ddb6SLionel Sambuc _ForwardIterator1 __m1 = __first1; 901*4684ddb6SLionel Sambuc _ForwardIterator2 __m2 = __first2; 902*4684ddb6SLionel Sambuc while (true) 903*4684ddb6SLionel Sambuc { 904*4684ddb6SLionel Sambuc if (++__m2 == __last2) 905*4684ddb6SLionel Sambuc { // Pattern exhaused, record answer and search for another one 906*4684ddb6SLionel Sambuc __r = __first1; 907*4684ddb6SLionel Sambuc ++__first1; 908*4684ddb6SLionel Sambuc break; 909*4684ddb6SLionel Sambuc } 910*4684ddb6SLionel Sambuc if (++__m1 == __last1) // Source exhausted, return last answer 911*4684ddb6SLionel Sambuc return __r; 912*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) // mismatch, restart with a new __first 913*4684ddb6SLionel Sambuc { 914*4684ddb6SLionel Sambuc ++__first1; 915*4684ddb6SLionel Sambuc break; 916*4684ddb6SLionel Sambuc } // else there is a match, check next elements 917*4684ddb6SLionel Sambuc } 918*4684ddb6SLionel Sambuc } 919*4684ddb6SLionel Sambuc} 920*4684ddb6SLionel Sambuc 921*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2> 922*4684ddb6SLionel Sambuc_BidirectionalIterator1 923*4684ddb6SLionel Sambuc__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, 924*4684ddb6SLionel Sambuc _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred, 925*4684ddb6SLionel Sambuc bidirectional_iterator_tag, bidirectional_iterator_tag) 926*4684ddb6SLionel Sambuc{ 927*4684ddb6SLionel Sambuc // modeled after search algorithm (in reverse) 928*4684ddb6SLionel Sambuc if (__first2 == __last2) 929*4684ddb6SLionel Sambuc return __last1; // Everything matches an empty sequence 930*4684ddb6SLionel Sambuc _BidirectionalIterator1 __l1 = __last1; 931*4684ddb6SLionel Sambuc _BidirectionalIterator2 __l2 = __last2; 932*4684ddb6SLionel Sambuc --__l2; 933*4684ddb6SLionel Sambuc while (true) 934*4684ddb6SLionel Sambuc { 935*4684ddb6SLionel Sambuc // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks 936*4684ddb6SLionel Sambuc while (true) 937*4684ddb6SLionel Sambuc { 938*4684ddb6SLionel Sambuc if (__first1 == __l1) // return __last1 if no element matches *__first2 939*4684ddb6SLionel Sambuc return __last1; 940*4684ddb6SLionel Sambuc if (__pred(*--__l1, *__l2)) 941*4684ddb6SLionel Sambuc break; 942*4684ddb6SLionel Sambuc } 943*4684ddb6SLionel Sambuc // *__l1 matches *__l2, now match elements before here 944*4684ddb6SLionel Sambuc _BidirectionalIterator1 __m1 = __l1; 945*4684ddb6SLionel Sambuc _BidirectionalIterator2 __m2 = __l2; 946*4684ddb6SLionel Sambuc while (true) 947*4684ddb6SLionel Sambuc { 948*4684ddb6SLionel Sambuc if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern) 949*4684ddb6SLionel Sambuc return __m1; 950*4684ddb6SLionel Sambuc if (__m1 == __first1) // Otherwise if source exhaused, pattern not found 951*4684ddb6SLionel Sambuc return __last1; 952*4684ddb6SLionel Sambuc if (!__pred(*--__m1, *--__m2)) // if there is a mismatch, restart with a new __l1 953*4684ddb6SLionel Sambuc { 954*4684ddb6SLionel Sambuc break; 955*4684ddb6SLionel Sambuc } // else there is a match, check next elements 956*4684ddb6SLionel Sambuc } 957*4684ddb6SLionel Sambuc } 958*4684ddb6SLionel Sambuc} 959*4684ddb6SLionel Sambuc 960*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 961*4684ddb6SLionel Sambuc_RandomAccessIterator1 962*4684ddb6SLionel Sambuc__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 963*4684ddb6SLionel Sambuc _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 964*4684ddb6SLionel Sambuc random_access_iterator_tag, random_access_iterator_tag) 965*4684ddb6SLionel Sambuc{ 966*4684ddb6SLionel Sambuc // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 967*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2; 968*4684ddb6SLionel Sambuc if (__len2 == 0) 969*4684ddb6SLionel Sambuc return __last1; 970*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1; 971*4684ddb6SLionel Sambuc if (__len1 < __len2) 972*4684ddb6SLionel Sambuc return __last1; 973*4684ddb6SLionel Sambuc const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here 974*4684ddb6SLionel Sambuc _RandomAccessIterator1 __l1 = __last1; 975*4684ddb6SLionel Sambuc _RandomAccessIterator2 __l2 = __last2; 976*4684ddb6SLionel Sambuc --__l2; 977*4684ddb6SLionel Sambuc while (true) 978*4684ddb6SLionel Sambuc { 979*4684ddb6SLionel Sambuc while (true) 980*4684ddb6SLionel Sambuc { 981*4684ddb6SLionel Sambuc if (__s == __l1) 982*4684ddb6SLionel Sambuc return __last1; 983*4684ddb6SLionel Sambuc if (__pred(*--__l1, *__l2)) 984*4684ddb6SLionel Sambuc break; 985*4684ddb6SLionel Sambuc } 986*4684ddb6SLionel Sambuc _RandomAccessIterator1 __m1 = __l1; 987*4684ddb6SLionel Sambuc _RandomAccessIterator2 __m2 = __l2; 988*4684ddb6SLionel Sambuc while (true) 989*4684ddb6SLionel Sambuc { 990*4684ddb6SLionel Sambuc if (__m2 == __first2) 991*4684ddb6SLionel Sambuc return __m1; 992*4684ddb6SLionel Sambuc // no need to check range on __m1 because __s guarantees we have enough source 993*4684ddb6SLionel Sambuc if (!__pred(*--__m1, *--__m2)) 994*4684ddb6SLionel Sambuc { 995*4684ddb6SLionel Sambuc break; 996*4684ddb6SLionel Sambuc } 997*4684ddb6SLionel Sambuc } 998*4684ddb6SLionel Sambuc } 999*4684ddb6SLionel Sambuc} 1000*4684ddb6SLionel Sambuc 1001*4684ddb6SLionel Sambuctemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1002*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1003*4684ddb6SLionel Sambuc_ForwardIterator1 1004*4684ddb6SLionel Sambucfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1005*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1006*4684ddb6SLionel Sambuc{ 1007*4684ddb6SLionel Sambuc return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type> 1008*4684ddb6SLionel Sambuc (__first1, __last1, __first2, __last2, __pred, 1009*4684ddb6SLionel Sambuc typename iterator_traits<_ForwardIterator1>::iterator_category(), 1010*4684ddb6SLionel Sambuc typename iterator_traits<_ForwardIterator2>::iterator_category()); 1011*4684ddb6SLionel Sambuc} 1012*4684ddb6SLionel Sambuc 1013*4684ddb6SLionel Sambuctemplate <class _ForwardIterator1, class _ForwardIterator2> 1014*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1015*4684ddb6SLionel Sambuc_ForwardIterator1 1016*4684ddb6SLionel Sambucfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1017*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1018*4684ddb6SLionel Sambuc{ 1019*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1020*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1021*4684ddb6SLionel Sambuc return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1022*4684ddb6SLionel Sambuc} 1023*4684ddb6SLionel Sambuc 1024*4684ddb6SLionel Sambuc// find_first_of 1025*4684ddb6SLionel Sambuc 1026*4684ddb6SLionel Sambuctemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1027*4684ddb6SLionel Sambuc_ForwardIterator1 1028*4684ddb6SLionel Sambucfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1029*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1030*4684ddb6SLionel Sambuc{ 1031*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1) 1032*4684ddb6SLionel Sambuc for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 1033*4684ddb6SLionel Sambuc if (__pred(*__first1, *__j)) 1034*4684ddb6SLionel Sambuc return __first1; 1035*4684ddb6SLionel Sambuc return __last1; 1036*4684ddb6SLionel Sambuc} 1037*4684ddb6SLionel Sambuc 1038*4684ddb6SLionel Sambuctemplate <class _ForwardIterator1, class _ForwardIterator2> 1039*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1040*4684ddb6SLionel Sambuc_ForwardIterator1 1041*4684ddb6SLionel Sambucfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1042*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1043*4684ddb6SLionel Sambuc{ 1044*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1045*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1046*4684ddb6SLionel Sambuc return _VSTD::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1047*4684ddb6SLionel Sambuc} 1048*4684ddb6SLionel Sambuc 1049*4684ddb6SLionel Sambuc// adjacent_find 1050*4684ddb6SLionel Sambuc 1051*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _BinaryPredicate> 1052*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1053*4684ddb6SLionel Sambuc_ForwardIterator 1054*4684ddb6SLionel Sambucadjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 1055*4684ddb6SLionel Sambuc{ 1056*4684ddb6SLionel Sambuc if (__first != __last) 1057*4684ddb6SLionel Sambuc { 1058*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 1059*4684ddb6SLionel Sambuc while (++__i != __last) 1060*4684ddb6SLionel Sambuc { 1061*4684ddb6SLionel Sambuc if (__pred(*__first, *__i)) 1062*4684ddb6SLionel Sambuc return __first; 1063*4684ddb6SLionel Sambuc __first = __i; 1064*4684ddb6SLionel Sambuc } 1065*4684ddb6SLionel Sambuc } 1066*4684ddb6SLionel Sambuc return __last; 1067*4684ddb6SLionel Sambuc} 1068*4684ddb6SLionel Sambuc 1069*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 1070*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1071*4684ddb6SLionel Sambuc_ForwardIterator 1072*4684ddb6SLionel Sambucadjacent_find(_ForwardIterator __first, _ForwardIterator __last) 1073*4684ddb6SLionel Sambuc{ 1074*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::value_type __v; 1075*4684ddb6SLionel Sambuc return _VSTD::adjacent_find(__first, __last, __equal_to<__v>()); 1076*4684ddb6SLionel Sambuc} 1077*4684ddb6SLionel Sambuc 1078*4684ddb6SLionel Sambuc// count 1079*4684ddb6SLionel Sambuc 1080*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Tp> 1081*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1082*4684ddb6SLionel Sambuctypename iterator_traits<_InputIterator>::difference_type 1083*4684ddb6SLionel Sambuccount(_InputIterator __first, _InputIterator __last, const _Tp& __value_) 1084*4684ddb6SLionel Sambuc{ 1085*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator>::difference_type __r(0); 1086*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 1087*4684ddb6SLionel Sambuc if (*__first == __value_) 1088*4684ddb6SLionel Sambuc ++__r; 1089*4684ddb6SLionel Sambuc return __r; 1090*4684ddb6SLionel Sambuc} 1091*4684ddb6SLionel Sambuc 1092*4684ddb6SLionel Sambuc// count_if 1093*4684ddb6SLionel Sambuc 1094*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Predicate> 1095*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1096*4684ddb6SLionel Sambuctypename iterator_traits<_InputIterator>::difference_type 1097*4684ddb6SLionel Sambuccount_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) 1098*4684ddb6SLionel Sambuc{ 1099*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator>::difference_type __r(0); 1100*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 1101*4684ddb6SLionel Sambuc if (__pred(*__first)) 1102*4684ddb6SLionel Sambuc ++__r; 1103*4684ddb6SLionel Sambuc return __r; 1104*4684ddb6SLionel Sambuc} 1105*4684ddb6SLionel Sambuc 1106*4684ddb6SLionel Sambuc// mismatch 1107*4684ddb6SLionel Sambuc 1108*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1109*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1110*4684ddb6SLionel Sambucpair<_InputIterator1, _InputIterator2> 1111*4684ddb6SLionel Sambucmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 1112*4684ddb6SLionel Sambuc _InputIterator2 __first2, _BinaryPredicate __pred) 1113*4684ddb6SLionel Sambuc{ 1114*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1, ++__first2) 1115*4684ddb6SLionel Sambuc if (!__pred(*__first1, *__first2)) 1116*4684ddb6SLionel Sambuc break; 1117*4684ddb6SLionel Sambuc return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 1118*4684ddb6SLionel Sambuc} 1119*4684ddb6SLionel Sambuc 1120*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2> 1121*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1122*4684ddb6SLionel Sambucpair<_InputIterator1, _InputIterator2> 1123*4684ddb6SLionel Sambucmismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 1124*4684ddb6SLionel Sambuc{ 1125*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1126*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1127*4684ddb6SLionel Sambuc return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 1128*4684ddb6SLionel Sambuc} 1129*4684ddb6SLionel Sambuc 1130*4684ddb6SLionel Sambuc#if _LIBCPP_STD_VER > 11 1131*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1132*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1133*4684ddb6SLionel Sambucpair<_InputIterator1, _InputIterator2> 1134*4684ddb6SLionel Sambucmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 1135*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, 1136*4684ddb6SLionel Sambuc _BinaryPredicate __pred) 1137*4684ddb6SLionel Sambuc{ 1138*4684ddb6SLionel Sambuc for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 1139*4684ddb6SLionel Sambuc if (!__pred(*__first1, *__first2)) 1140*4684ddb6SLionel Sambuc break; 1141*4684ddb6SLionel Sambuc return pair<_InputIterator1, _InputIterator2>(__first1, __first2); 1142*4684ddb6SLionel Sambuc} 1143*4684ddb6SLionel Sambuc 1144*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2> 1145*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1146*4684ddb6SLionel Sambucpair<_InputIterator1, _InputIterator2> 1147*4684ddb6SLionel Sambucmismatch(_InputIterator1 __first1, _InputIterator1 __last1, 1148*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2) 1149*4684ddb6SLionel Sambuc{ 1150*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1151*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1152*4684ddb6SLionel Sambuc return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1153*4684ddb6SLionel Sambuc} 1154*4684ddb6SLionel Sambuc#endif 1155*4684ddb6SLionel Sambuc 1156*4684ddb6SLionel Sambuc// equal 1157*4684ddb6SLionel Sambuc 1158*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1159*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1160*4684ddb6SLionel Sambucbool 1161*4684ddb6SLionel Sambucequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) 1162*4684ddb6SLionel Sambuc{ 1163*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1, ++__first2) 1164*4684ddb6SLionel Sambuc if (!__pred(*__first1, *__first2)) 1165*4684ddb6SLionel Sambuc return false; 1166*4684ddb6SLionel Sambuc return true; 1167*4684ddb6SLionel Sambuc} 1168*4684ddb6SLionel Sambuc 1169*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2> 1170*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1171*4684ddb6SLionel Sambucbool 1172*4684ddb6SLionel Sambucequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) 1173*4684ddb6SLionel Sambuc{ 1174*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1175*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1176*4684ddb6SLionel Sambuc return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 1177*4684ddb6SLionel Sambuc} 1178*4684ddb6SLionel Sambuc 1179*4684ddb6SLionel Sambuc#if _LIBCPP_STD_VER > 11 1180*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _InputIterator1, class _InputIterator2> 1181*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1182*4684ddb6SLionel Sambucbool 1183*4684ddb6SLionel Sambuc__equal(_InputIterator1 __first1, _InputIterator1 __last1, 1184*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred, 1185*4684ddb6SLionel Sambuc input_iterator_tag, input_iterator_tag ) 1186*4684ddb6SLionel Sambuc{ 1187*4684ddb6SLionel Sambuc for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 1188*4684ddb6SLionel Sambuc if (!__pred(*__first1, *__first2)) 1189*4684ddb6SLionel Sambuc return false; 1190*4684ddb6SLionel Sambuc return __first1 == __last1 && __first2 == __last2; 1191*4684ddb6SLionel Sambuc} 1192*4684ddb6SLionel Sambuc 1193*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1194*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1195*4684ddb6SLionel Sambucbool 1196*4684ddb6SLionel Sambuc__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 1197*4684ddb6SLionel Sambuc _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 1198*4684ddb6SLionel Sambuc random_access_iterator_tag, random_access_iterator_tag ) 1199*4684ddb6SLionel Sambuc{ 1200*4684ddb6SLionel Sambuc if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) 1201*4684ddb6SLionel Sambuc return false; 1202*4684ddb6SLionel Sambuc return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2, 1203*4684ddb6SLionel Sambuc typename add_lvalue_reference<_BinaryPredicate>::type> 1204*4684ddb6SLionel Sambuc (__first1, __last1, __first2, __pred ); 1205*4684ddb6SLionel Sambuc} 1206*4684ddb6SLionel Sambuc 1207*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> 1208*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1209*4684ddb6SLionel Sambucbool 1210*4684ddb6SLionel Sambucequal(_InputIterator1 __first1, _InputIterator1 __last1, 1211*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred ) 1212*4684ddb6SLionel Sambuc{ 1213*4684ddb6SLionel Sambuc return _VSTD::__equal<typename add_lvalue_reference<_BinaryPredicate>::type> 1214*4684ddb6SLionel Sambuc (__first1, __last1, __first2, __last2, __pred, 1215*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator1>::iterator_category(), 1216*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::iterator_category()); 1217*4684ddb6SLionel Sambuc} 1218*4684ddb6SLionel Sambuc 1219*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2> 1220*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1221*4684ddb6SLionel Sambucbool 1222*4684ddb6SLionel Sambucequal(_InputIterator1 __first1, _InputIterator1 __last1, 1223*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2) 1224*4684ddb6SLionel Sambuc{ 1225*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator1>::value_type __v1; 1226*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator2>::value_type __v2; 1227*4684ddb6SLionel Sambuc return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), 1228*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator1>::iterator_category(), 1229*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::iterator_category()); 1230*4684ddb6SLionel Sambuc} 1231*4684ddb6SLionel Sambuc#endif 1232*4684ddb6SLionel Sambuc 1233*4684ddb6SLionel Sambuc// is_permutation 1234*4684ddb6SLionel Sambuc 1235*4684ddb6SLionel Sambuctemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1236*4684ddb6SLionel Sambucbool 1237*4684ddb6SLionel Sambucis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1238*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _BinaryPredicate __pred) 1239*4684ddb6SLionel Sambuc{ 1240*4684ddb6SLionel Sambuc // shorten sequences as much as possible by lopping of any equal parts 1241*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1, ++__first2) 1242*4684ddb6SLionel Sambuc if (!__pred(*__first1, *__first2)) 1243*4684ddb6SLionel Sambuc goto __not_done; 1244*4684ddb6SLionel Sambuc return true; 1245*4684ddb6SLionel Sambuc__not_done: 1246*4684ddb6SLionel Sambuc // __first1 != __last1 && *__first1 != *__first2 1247*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 1248*4684ddb6SLionel Sambuc _D1 __l1 = _VSTD::distance(__first1, __last1); 1249*4684ddb6SLionel Sambuc if (__l1 == _D1(1)) 1250*4684ddb6SLionel Sambuc return false; 1251*4684ddb6SLionel Sambuc _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1); 1252*4684ddb6SLionel Sambuc // For each element in [f1, l1) see if there are the same number of 1253*4684ddb6SLionel Sambuc // equal elements in [f2, l2) 1254*4684ddb6SLionel Sambuc for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 1255*4684ddb6SLionel Sambuc { 1256*4684ddb6SLionel Sambuc // Have we already counted the number of *__i in [f1, l1)? 1257*4684ddb6SLionel Sambuc for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 1258*4684ddb6SLionel Sambuc if (__pred(*__j, *__i)) 1259*4684ddb6SLionel Sambuc goto __next_iter; 1260*4684ddb6SLionel Sambuc { 1261*4684ddb6SLionel Sambuc // Count number of *__i in [f2, l2) 1262*4684ddb6SLionel Sambuc _D1 __c2 = 0; 1263*4684ddb6SLionel Sambuc for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 1264*4684ddb6SLionel Sambuc if (__pred(*__i, *__j)) 1265*4684ddb6SLionel Sambuc ++__c2; 1266*4684ddb6SLionel Sambuc if (__c2 == 0) 1267*4684ddb6SLionel Sambuc return false; 1268*4684ddb6SLionel Sambuc // Count number of *__i in [__i, l1) (we can start with 1) 1269*4684ddb6SLionel Sambuc _D1 __c1 = 1; 1270*4684ddb6SLionel Sambuc for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 1271*4684ddb6SLionel Sambuc if (__pred(*__i, *__j)) 1272*4684ddb6SLionel Sambuc ++__c1; 1273*4684ddb6SLionel Sambuc if (__c1 != __c2) 1274*4684ddb6SLionel Sambuc return false; 1275*4684ddb6SLionel Sambuc } 1276*4684ddb6SLionel Sambuc__next_iter:; 1277*4684ddb6SLionel Sambuc } 1278*4684ddb6SLionel Sambuc return true; 1279*4684ddb6SLionel Sambuc} 1280*4684ddb6SLionel Sambuc 1281*4684ddb6SLionel Sambuctemplate<class _ForwardIterator1, class _ForwardIterator2> 1282*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1283*4684ddb6SLionel Sambucbool 1284*4684ddb6SLionel Sambucis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1285*4684ddb6SLionel Sambuc _ForwardIterator2 __first2) 1286*4684ddb6SLionel Sambuc{ 1287*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1288*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1289*4684ddb6SLionel Sambuc return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); 1290*4684ddb6SLionel Sambuc} 1291*4684ddb6SLionel Sambuc 1292*4684ddb6SLionel Sambuc#if _LIBCPP_STD_VER > 11 1293*4684ddb6SLionel Sambuctemplate<class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 1294*4684ddb6SLionel Sambucbool 1295*4684ddb6SLionel Sambuc__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1296*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, 1297*4684ddb6SLionel Sambuc _BinaryPredicate __pred, 1298*4684ddb6SLionel Sambuc forward_iterator_tag, forward_iterator_tag ) 1299*4684ddb6SLionel Sambuc{ 1300*4684ddb6SLionel Sambuc // shorten sequences as much as possible by lopping of any equal parts 1301*4684ddb6SLionel Sambuc for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) 1302*4684ddb6SLionel Sambuc if (!__pred(*__first1, *__first2)) 1303*4684ddb6SLionel Sambuc goto __not_done; 1304*4684ddb6SLionel Sambuc return __first1 == __last1 && __first2 == __last2; 1305*4684ddb6SLionel Sambuc__not_done: 1306*4684ddb6SLionel Sambuc // __first1 != __last1 && __first2 != __last2 && *__first1 != *__first2 1307*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; 1308*4684ddb6SLionel Sambuc _D1 __l1 = _VSTD::distance(__first1, __last1); 1309*4684ddb6SLionel Sambuc 1310*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2; 1311*4684ddb6SLionel Sambuc _D2 __l2 = _VSTD::distance(__first2, __last2); 1312*4684ddb6SLionel Sambuc if (__l1 != __l2) 1313*4684ddb6SLionel Sambuc return false; 1314*4684ddb6SLionel Sambuc 1315*4684ddb6SLionel Sambuc // For each element in [f1, l1) see if there are the same number of 1316*4684ddb6SLionel Sambuc // equal elements in [f2, l2) 1317*4684ddb6SLionel Sambuc for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) 1318*4684ddb6SLionel Sambuc { 1319*4684ddb6SLionel Sambuc // Have we already counted the number of *__i in [f1, l1)? 1320*4684ddb6SLionel Sambuc for (_ForwardIterator1 __j = __first1; __j != __i; ++__j) 1321*4684ddb6SLionel Sambuc if (__pred(*__j, *__i)) 1322*4684ddb6SLionel Sambuc goto __next_iter; 1323*4684ddb6SLionel Sambuc { 1324*4684ddb6SLionel Sambuc // Count number of *__i in [f2, l2) 1325*4684ddb6SLionel Sambuc _D1 __c2 = 0; 1326*4684ddb6SLionel Sambuc for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j) 1327*4684ddb6SLionel Sambuc if (__pred(*__i, *__j)) 1328*4684ddb6SLionel Sambuc ++__c2; 1329*4684ddb6SLionel Sambuc if (__c2 == 0) 1330*4684ddb6SLionel Sambuc return false; 1331*4684ddb6SLionel Sambuc // Count number of *__i in [__i, l1) (we can start with 1) 1332*4684ddb6SLionel Sambuc _D1 __c1 = 1; 1333*4684ddb6SLionel Sambuc for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) 1334*4684ddb6SLionel Sambuc if (__pred(*__i, *__j)) 1335*4684ddb6SLionel Sambuc ++__c1; 1336*4684ddb6SLionel Sambuc if (__c1 != __c2) 1337*4684ddb6SLionel Sambuc return false; 1338*4684ddb6SLionel Sambuc } 1339*4684ddb6SLionel Sambuc__next_iter:; 1340*4684ddb6SLionel Sambuc } 1341*4684ddb6SLionel Sambuc return true; 1342*4684ddb6SLionel Sambuc} 1343*4684ddb6SLionel Sambuc 1344*4684ddb6SLionel Sambuctemplate<class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1345*4684ddb6SLionel Sambucbool 1346*4684ddb6SLionel Sambuc__is_permutation(_RandomAccessIterator1 __first1, _RandomAccessIterator2 __last1, 1347*4684ddb6SLionel Sambuc _RandomAccessIterator1 __first2, _RandomAccessIterator2 __last2, 1348*4684ddb6SLionel Sambuc _BinaryPredicate __pred, 1349*4684ddb6SLionel Sambuc random_access_iterator_tag, random_access_iterator_tag ) 1350*4684ddb6SLionel Sambuc{ 1351*4684ddb6SLionel Sambuc if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) 1352*4684ddb6SLionel Sambuc return false; 1353*4684ddb6SLionel Sambuc return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2, 1354*4684ddb6SLionel Sambuc typename add_lvalue_reference<_BinaryPredicate>::type> 1355*4684ddb6SLionel Sambuc (__first1, __last1, __first2, __pred ); 1356*4684ddb6SLionel Sambuc} 1357*4684ddb6SLionel Sambuc 1358*4684ddb6SLionel Sambuctemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1359*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1360*4684ddb6SLionel Sambucbool 1361*4684ddb6SLionel Sambucis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1362*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, 1363*4684ddb6SLionel Sambuc _BinaryPredicate __pred ) 1364*4684ddb6SLionel Sambuc{ 1365*4684ddb6SLionel Sambuc return _VSTD::__is_permutation<typename add_lvalue_reference<_BinaryPredicate>::type> 1366*4684ddb6SLionel Sambuc (__first1, __last1, __first2, __last2, __pred, 1367*4684ddb6SLionel Sambuc typename iterator_traits<_ForwardIterator1>::iterator_category(), 1368*4684ddb6SLionel Sambuc typename iterator_traits<_ForwardIterator2>::iterator_category()); 1369*4684ddb6SLionel Sambuc} 1370*4684ddb6SLionel Sambuc 1371*4684ddb6SLionel Sambuctemplate<class _ForwardIterator1, class _ForwardIterator2> 1372*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1373*4684ddb6SLionel Sambucbool 1374*4684ddb6SLionel Sambucis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1375*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1376*4684ddb6SLionel Sambuc{ 1377*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; 1378*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; 1379*4684ddb6SLionel Sambuc return _VSTD::__is_permutation(__first1, __last1, __first2, __last2, 1380*4684ddb6SLionel Sambuc __equal_to<__v1, __v2>(), 1381*4684ddb6SLionel Sambuc typename iterator_traits<_ForwardIterator1>::iterator_category(), 1382*4684ddb6SLionel Sambuc typename iterator_traits<_ForwardIterator2>::iterator_category()); 1383*4684ddb6SLionel Sambuc} 1384*4684ddb6SLionel Sambuc#endif 1385*4684ddb6SLionel Sambuc 1386*4684ddb6SLionel Sambuc// search 1387*4684ddb6SLionel Sambuc 1388*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2> 1389*4684ddb6SLionel Sambuc_ForwardIterator1 1390*4684ddb6SLionel Sambuc__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1391*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred, 1392*4684ddb6SLionel Sambuc forward_iterator_tag, forward_iterator_tag) 1393*4684ddb6SLionel Sambuc{ 1394*4684ddb6SLionel Sambuc if (__first2 == __last2) 1395*4684ddb6SLionel Sambuc return __first1; // Everything matches an empty sequence 1396*4684ddb6SLionel Sambuc while (true) 1397*4684ddb6SLionel Sambuc { 1398*4684ddb6SLionel Sambuc // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks 1399*4684ddb6SLionel Sambuc while (true) 1400*4684ddb6SLionel Sambuc { 1401*4684ddb6SLionel Sambuc if (__first1 == __last1) // return __last1 if no element matches *__first2 1402*4684ddb6SLionel Sambuc return __last1; 1403*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 1404*4684ddb6SLionel Sambuc break; 1405*4684ddb6SLionel Sambuc ++__first1; 1406*4684ddb6SLionel Sambuc } 1407*4684ddb6SLionel Sambuc // *__first1 matches *__first2, now match elements after here 1408*4684ddb6SLionel Sambuc _ForwardIterator1 __m1 = __first1; 1409*4684ddb6SLionel Sambuc _ForwardIterator2 __m2 = __first2; 1410*4684ddb6SLionel Sambuc while (true) 1411*4684ddb6SLionel Sambuc { 1412*4684ddb6SLionel Sambuc if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern) 1413*4684ddb6SLionel Sambuc return __first1; 1414*4684ddb6SLionel Sambuc if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found 1415*4684ddb6SLionel Sambuc return __last1; 1416*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) // if there is a mismatch, restart with a new __first1 1417*4684ddb6SLionel Sambuc { 1418*4684ddb6SLionel Sambuc ++__first1; 1419*4684ddb6SLionel Sambuc break; 1420*4684ddb6SLionel Sambuc } // else there is a match, check next elements 1421*4684ddb6SLionel Sambuc } 1422*4684ddb6SLionel Sambuc } 1423*4684ddb6SLionel Sambuc} 1424*4684ddb6SLionel Sambuc 1425*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2> 1426*4684ddb6SLionel Sambuc_RandomAccessIterator1 1427*4684ddb6SLionel Sambuc__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, 1428*4684ddb6SLionel Sambuc _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, 1429*4684ddb6SLionel Sambuc random_access_iterator_tag, random_access_iterator_tag) 1430*4684ddb6SLionel Sambuc{ 1431*4684ddb6SLionel Sambuc typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _D1; 1432*4684ddb6SLionel Sambuc typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _D2; 1433*4684ddb6SLionel Sambuc // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern 1434*4684ddb6SLionel Sambuc _D2 __len2 = __last2 - __first2; 1435*4684ddb6SLionel Sambuc if (__len2 == 0) 1436*4684ddb6SLionel Sambuc return __first1; 1437*4684ddb6SLionel Sambuc _D1 __len1 = __last1 - __first1; 1438*4684ddb6SLionel Sambuc if (__len1 < __len2) 1439*4684ddb6SLionel Sambuc return __last1; 1440*4684ddb6SLionel Sambuc const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here 1441*4684ddb6SLionel Sambuc while (true) 1442*4684ddb6SLionel Sambuc { 1443*4684ddb6SLionel Sambuc#if !_LIBCPP_UNROLL_LOOPS 1444*4684ddb6SLionel Sambuc while (true) 1445*4684ddb6SLionel Sambuc { 1446*4684ddb6SLionel Sambuc if (__first1 == __s) 1447*4684ddb6SLionel Sambuc return __last1; 1448*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 1449*4684ddb6SLionel Sambuc break; 1450*4684ddb6SLionel Sambuc ++__first1; 1451*4684ddb6SLionel Sambuc } 1452*4684ddb6SLionel Sambuc#else // !_LIBCPP_UNROLL_LOOPS 1453*4684ddb6SLionel Sambuc for (_D1 __loop_unroll = (__s - __first1) / 4; __loop_unroll > 0; --__loop_unroll) 1454*4684ddb6SLionel Sambuc { 1455*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 1456*4684ddb6SLionel Sambuc goto __phase2; 1457*4684ddb6SLionel Sambuc if (__pred(*++__first1, *__first2)) 1458*4684ddb6SLionel Sambuc goto __phase2; 1459*4684ddb6SLionel Sambuc if (__pred(*++__first1, *__first2)) 1460*4684ddb6SLionel Sambuc goto __phase2; 1461*4684ddb6SLionel Sambuc if (__pred(*++__first1, *__first2)) 1462*4684ddb6SLionel Sambuc goto __phase2; 1463*4684ddb6SLionel Sambuc ++__first1; 1464*4684ddb6SLionel Sambuc } 1465*4684ddb6SLionel Sambuc switch (__s - __first1) 1466*4684ddb6SLionel Sambuc { 1467*4684ddb6SLionel Sambuc case 3: 1468*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 1469*4684ddb6SLionel Sambuc break; 1470*4684ddb6SLionel Sambuc ++__first1; 1471*4684ddb6SLionel Sambuc case 2: 1472*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 1473*4684ddb6SLionel Sambuc break; 1474*4684ddb6SLionel Sambuc ++__first1; 1475*4684ddb6SLionel Sambuc case 1: 1476*4684ddb6SLionel Sambuc if (__pred(*__first1, *__first2)) 1477*4684ddb6SLionel Sambuc break; 1478*4684ddb6SLionel Sambuc case 0: 1479*4684ddb6SLionel Sambuc return __last1; 1480*4684ddb6SLionel Sambuc } 1481*4684ddb6SLionel Sambuc __phase2: 1482*4684ddb6SLionel Sambuc#endif // !_LIBCPP_UNROLL_LOOPS 1483*4684ddb6SLionel Sambuc _RandomAccessIterator1 __m1 = __first1; 1484*4684ddb6SLionel Sambuc _RandomAccessIterator2 __m2 = __first2; 1485*4684ddb6SLionel Sambuc#if !_LIBCPP_UNROLL_LOOPS 1486*4684ddb6SLionel Sambuc while (true) 1487*4684ddb6SLionel Sambuc { 1488*4684ddb6SLionel Sambuc if (++__m2 == __last2) 1489*4684ddb6SLionel Sambuc return __first1; 1490*4684ddb6SLionel Sambuc ++__m1; // no need to check range on __m1 because __s guarantees we have enough source 1491*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) 1492*4684ddb6SLionel Sambuc { 1493*4684ddb6SLionel Sambuc ++__first1; 1494*4684ddb6SLionel Sambuc break; 1495*4684ddb6SLionel Sambuc } 1496*4684ddb6SLionel Sambuc } 1497*4684ddb6SLionel Sambuc#else // !_LIBCPP_UNROLL_LOOPS 1498*4684ddb6SLionel Sambuc ++__m2; 1499*4684ddb6SLionel Sambuc ++__m1; 1500*4684ddb6SLionel Sambuc for (_D2 __loop_unroll = (__last2 - __m2) / 4; __loop_unroll > 0; --__loop_unroll) 1501*4684ddb6SLionel Sambuc { 1502*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) 1503*4684ddb6SLionel Sambuc goto __continue; 1504*4684ddb6SLionel Sambuc if (!__pred(*++__m1, *++__m2)) 1505*4684ddb6SLionel Sambuc goto __continue; 1506*4684ddb6SLionel Sambuc if (!__pred(*++__m1, *++__m2)) 1507*4684ddb6SLionel Sambuc goto __continue; 1508*4684ddb6SLionel Sambuc if (!__pred(*++__m1, *++__m2)) 1509*4684ddb6SLionel Sambuc goto __continue; 1510*4684ddb6SLionel Sambuc ++__m1; 1511*4684ddb6SLionel Sambuc ++__m2; 1512*4684ddb6SLionel Sambuc } 1513*4684ddb6SLionel Sambuc switch (__last2 - __m2) 1514*4684ddb6SLionel Sambuc { 1515*4684ddb6SLionel Sambuc case 3: 1516*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) 1517*4684ddb6SLionel Sambuc break; 1518*4684ddb6SLionel Sambuc ++__m1; 1519*4684ddb6SLionel Sambuc ++__m2; 1520*4684ddb6SLionel Sambuc case 2: 1521*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) 1522*4684ddb6SLionel Sambuc break; 1523*4684ddb6SLionel Sambuc ++__m1; 1524*4684ddb6SLionel Sambuc ++__m2; 1525*4684ddb6SLionel Sambuc case 1: 1526*4684ddb6SLionel Sambuc if (!__pred(*__m1, *__m2)) 1527*4684ddb6SLionel Sambuc break; 1528*4684ddb6SLionel Sambuc case 0: 1529*4684ddb6SLionel Sambuc return __first1; 1530*4684ddb6SLionel Sambuc } 1531*4684ddb6SLionel Sambuc __continue: 1532*4684ddb6SLionel Sambuc ++__first1; 1533*4684ddb6SLionel Sambuc#endif // !_LIBCPP_UNROLL_LOOPS 1534*4684ddb6SLionel Sambuc } 1535*4684ddb6SLionel Sambuc} 1536*4684ddb6SLionel Sambuc 1537*4684ddb6SLionel Sambuctemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> 1538*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1539*4684ddb6SLionel Sambuc_ForwardIterator1 1540*4684ddb6SLionel Sambucsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1541*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) 1542*4684ddb6SLionel Sambuc{ 1543*4684ddb6SLionel Sambuc return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type> 1544*4684ddb6SLionel Sambuc (__first1, __last1, __first2, __last2, __pred, 1545*4684ddb6SLionel Sambuc typename std::iterator_traits<_ForwardIterator1>::iterator_category(), 1546*4684ddb6SLionel Sambuc typename std::iterator_traits<_ForwardIterator2>::iterator_category()); 1547*4684ddb6SLionel Sambuc} 1548*4684ddb6SLionel Sambuc 1549*4684ddb6SLionel Sambuctemplate <class _ForwardIterator1, class _ForwardIterator2> 1550*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1551*4684ddb6SLionel Sambuc_ForwardIterator1 1552*4684ddb6SLionel Sambucsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, 1553*4684ddb6SLionel Sambuc _ForwardIterator2 __first2, _ForwardIterator2 __last2) 1554*4684ddb6SLionel Sambuc{ 1555*4684ddb6SLionel Sambuc typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1; 1556*4684ddb6SLionel Sambuc typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2; 1557*4684ddb6SLionel Sambuc return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); 1558*4684ddb6SLionel Sambuc} 1559*4684ddb6SLionel Sambuc 1560*4684ddb6SLionel Sambuc// search_n 1561*4684ddb6SLionel Sambuc 1562*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp> 1563*4684ddb6SLionel Sambuc_ForwardIterator 1564*4684ddb6SLionel Sambuc__search_n(_ForwardIterator __first, _ForwardIterator __last, 1565*4684ddb6SLionel Sambuc _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag) 1566*4684ddb6SLionel Sambuc{ 1567*4684ddb6SLionel Sambuc if (__count <= 0) 1568*4684ddb6SLionel Sambuc return __first; 1569*4684ddb6SLionel Sambuc while (true) 1570*4684ddb6SLionel Sambuc { 1571*4684ddb6SLionel Sambuc // Find first element in sequence that matchs __value_, with a mininum of loop checks 1572*4684ddb6SLionel Sambuc while (true) 1573*4684ddb6SLionel Sambuc { 1574*4684ddb6SLionel Sambuc if (__first == __last) // return __last if no element matches __value_ 1575*4684ddb6SLionel Sambuc return __last; 1576*4684ddb6SLionel Sambuc if (__pred(*__first, __value_)) 1577*4684ddb6SLionel Sambuc break; 1578*4684ddb6SLionel Sambuc ++__first; 1579*4684ddb6SLionel Sambuc } 1580*4684ddb6SLionel Sambuc // *__first matches __value_, now match elements after here 1581*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 1582*4684ddb6SLionel Sambuc _Size __c(0); 1583*4684ddb6SLionel Sambuc while (true) 1584*4684ddb6SLionel Sambuc { 1585*4684ddb6SLionel Sambuc if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 1586*4684ddb6SLionel Sambuc return __first; 1587*4684ddb6SLionel Sambuc if (++__m == __last) // Otherwise if source exhaused, pattern not found 1588*4684ddb6SLionel Sambuc return __last; 1589*4684ddb6SLionel Sambuc if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 1590*4684ddb6SLionel Sambuc { 1591*4684ddb6SLionel Sambuc __first = __m; 1592*4684ddb6SLionel Sambuc ++__first; 1593*4684ddb6SLionel Sambuc break; 1594*4684ddb6SLionel Sambuc } // else there is a match, check next elements 1595*4684ddb6SLionel Sambuc } 1596*4684ddb6SLionel Sambuc } 1597*4684ddb6SLionel Sambuc} 1598*4684ddb6SLionel Sambuc 1599*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp> 1600*4684ddb6SLionel Sambuc_RandomAccessIterator 1601*4684ddb6SLionel Sambuc__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last, 1602*4684ddb6SLionel Sambuc _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag) 1603*4684ddb6SLionel Sambuc{ 1604*4684ddb6SLionel Sambuc if (__count <= 0) 1605*4684ddb6SLionel Sambuc return __first; 1606*4684ddb6SLionel Sambuc _Size __len = static_cast<_Size>(__last - __first); 1607*4684ddb6SLionel Sambuc if (__len < __count) 1608*4684ddb6SLionel Sambuc return __last; 1609*4684ddb6SLionel Sambuc const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here 1610*4684ddb6SLionel Sambuc while (true) 1611*4684ddb6SLionel Sambuc { 1612*4684ddb6SLionel Sambuc // Find first element in sequence that matchs __value_, with a mininum of loop checks 1613*4684ddb6SLionel Sambuc while (true) 1614*4684ddb6SLionel Sambuc { 1615*4684ddb6SLionel Sambuc if (__first >= __s) // return __last if no element matches __value_ 1616*4684ddb6SLionel Sambuc return __last; 1617*4684ddb6SLionel Sambuc if (__pred(*__first, __value_)) 1618*4684ddb6SLionel Sambuc break; 1619*4684ddb6SLionel Sambuc ++__first; 1620*4684ddb6SLionel Sambuc } 1621*4684ddb6SLionel Sambuc // *__first matches __value_, now match elements after here 1622*4684ddb6SLionel Sambuc _RandomAccessIterator __m = __first; 1623*4684ddb6SLionel Sambuc _Size __c(0); 1624*4684ddb6SLionel Sambuc while (true) 1625*4684ddb6SLionel Sambuc { 1626*4684ddb6SLionel Sambuc if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern) 1627*4684ddb6SLionel Sambuc return __first; 1628*4684ddb6SLionel Sambuc ++__m; // no need to check range on __m because __s guarantees we have enough source 1629*4684ddb6SLionel Sambuc if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first 1630*4684ddb6SLionel Sambuc { 1631*4684ddb6SLionel Sambuc __first = __m; 1632*4684ddb6SLionel Sambuc ++__first; 1633*4684ddb6SLionel Sambuc break; 1634*4684ddb6SLionel Sambuc } // else there is a match, check next elements 1635*4684ddb6SLionel Sambuc } 1636*4684ddb6SLionel Sambuc } 1637*4684ddb6SLionel Sambuc} 1638*4684ddb6SLionel Sambuc 1639*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> 1640*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1641*4684ddb6SLionel Sambuc_ForwardIterator 1642*4684ddb6SLionel Sambucsearch_n(_ForwardIterator __first, _ForwardIterator __last, 1643*4684ddb6SLionel Sambuc _Size __count, const _Tp& __value_, _BinaryPredicate __pred) 1644*4684ddb6SLionel Sambuc{ 1645*4684ddb6SLionel Sambuc return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type> 1646*4684ddb6SLionel Sambuc (__first, __last, __count, __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 1647*4684ddb6SLionel Sambuc} 1648*4684ddb6SLionel Sambuc 1649*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Size, class _Tp> 1650*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1651*4684ddb6SLionel Sambuc_ForwardIterator 1652*4684ddb6SLionel Sambucsearch_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) 1653*4684ddb6SLionel Sambuc{ 1654*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::value_type __v; 1655*4684ddb6SLionel Sambuc return _VSTD::search_n(__first, __last, __count, __value_, __equal_to<__v, _Tp>()); 1656*4684ddb6SLionel Sambuc} 1657*4684ddb6SLionel Sambuc 1658*4684ddb6SLionel Sambuc// copy 1659*4684ddb6SLionel Sambuc 1660*4684ddb6SLionel Sambuctemplate <class _Iter> 1661*4684ddb6SLionel Sambucstruct __libcpp_is_trivial_iterator 1662*4684ddb6SLionel Sambuc{ 1663*4684ddb6SLionel Sambuc static const bool value = is_pointer<_Iter>::value; 1664*4684ddb6SLionel Sambuc}; 1665*4684ddb6SLionel Sambuc 1666*4684ddb6SLionel Sambuctemplate <class _Iter> 1667*4684ddb6SLionel Sambucstruct __libcpp_is_trivial_iterator<move_iterator<_Iter> > 1668*4684ddb6SLionel Sambuc{ 1669*4684ddb6SLionel Sambuc static const bool value = is_pointer<_Iter>::value; 1670*4684ddb6SLionel Sambuc}; 1671*4684ddb6SLionel Sambuc 1672*4684ddb6SLionel Sambuctemplate <class _Iter> 1673*4684ddb6SLionel Sambucstruct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> > 1674*4684ddb6SLionel Sambuc{ 1675*4684ddb6SLionel Sambuc static const bool value = is_pointer<_Iter>::value; 1676*4684ddb6SLionel Sambuc}; 1677*4684ddb6SLionel Sambuc 1678*4684ddb6SLionel Sambuctemplate <class _Iter> 1679*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1680*4684ddb6SLionel Sambuc_Iter 1681*4684ddb6SLionel Sambuc__unwrap_iter(_Iter __i) 1682*4684ddb6SLionel Sambuc{ 1683*4684ddb6SLionel Sambuc return __i; 1684*4684ddb6SLionel Sambuc} 1685*4684ddb6SLionel Sambuc 1686*4684ddb6SLionel Sambuctemplate <class _Tp> 1687*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1688*4684ddb6SLionel Sambuctypename enable_if 1689*4684ddb6SLionel Sambuc< 1690*4684ddb6SLionel Sambuc is_trivially_copy_assignable<_Tp>::value, 1691*4684ddb6SLionel Sambuc _Tp* 1692*4684ddb6SLionel Sambuc>::type 1693*4684ddb6SLionel Sambuc__unwrap_iter(move_iterator<_Tp*> __i) 1694*4684ddb6SLionel Sambuc{ 1695*4684ddb6SLionel Sambuc return __i.base(); 1696*4684ddb6SLionel Sambuc} 1697*4684ddb6SLionel Sambuc 1698*4684ddb6SLionel Sambuc#if _LIBCPP_DEBUG_LEVEL < 2 1699*4684ddb6SLionel Sambuc 1700*4684ddb6SLionel Sambuctemplate <class _Tp> 1701*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1702*4684ddb6SLionel Sambuctypename enable_if 1703*4684ddb6SLionel Sambuc< 1704*4684ddb6SLionel Sambuc is_trivially_copy_assignable<_Tp>::value, 1705*4684ddb6SLionel Sambuc _Tp* 1706*4684ddb6SLionel Sambuc>::type 1707*4684ddb6SLionel Sambuc__unwrap_iter(__wrap_iter<_Tp*> __i) 1708*4684ddb6SLionel Sambuc{ 1709*4684ddb6SLionel Sambuc return __i.base(); 1710*4684ddb6SLionel Sambuc} 1711*4684ddb6SLionel Sambuc 1712*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG_LEVEL < 2 1713*4684ddb6SLionel Sambuc 1714*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator> 1715*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1716*4684ddb6SLionel Sambuc_OutputIterator 1717*4684ddb6SLionel Sambuc__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1718*4684ddb6SLionel Sambuc{ 1719*4684ddb6SLionel Sambuc for (; __first != __last; ++__first, ++__result) 1720*4684ddb6SLionel Sambuc *__result = *__first; 1721*4684ddb6SLionel Sambuc return __result; 1722*4684ddb6SLionel Sambuc} 1723*4684ddb6SLionel Sambuc 1724*4684ddb6SLionel Sambuctemplate <class _Tp, class _Up> 1725*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1726*4684ddb6SLionel Sambuctypename enable_if 1727*4684ddb6SLionel Sambuc< 1728*4684ddb6SLionel Sambuc is_same<typename remove_const<_Tp>::type, _Up>::value && 1729*4684ddb6SLionel Sambuc is_trivially_copy_assignable<_Up>::value, 1730*4684ddb6SLionel Sambuc _Up* 1731*4684ddb6SLionel Sambuc>::type 1732*4684ddb6SLionel Sambuc__copy(_Tp* __first, _Tp* __last, _Up* __result) 1733*4684ddb6SLionel Sambuc{ 1734*4684ddb6SLionel Sambuc const size_t __n = static_cast<size_t>(__last - __first); 1735*4684ddb6SLionel Sambuc _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1736*4684ddb6SLionel Sambuc return __result + __n; 1737*4684ddb6SLionel Sambuc} 1738*4684ddb6SLionel Sambuc 1739*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator> 1740*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1741*4684ddb6SLionel Sambuc_OutputIterator 1742*4684ddb6SLionel Sambuccopy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1743*4684ddb6SLionel Sambuc{ 1744*4684ddb6SLionel Sambuc return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1745*4684ddb6SLionel Sambuc} 1746*4684ddb6SLionel Sambuc 1747*4684ddb6SLionel Sambuc// copy_backward 1748*4684ddb6SLionel Sambuc 1749*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator, class _OutputIterator> 1750*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1751*4684ddb6SLionel Sambuc_OutputIterator 1752*4684ddb6SLionel Sambuc__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 1753*4684ddb6SLionel Sambuc{ 1754*4684ddb6SLionel Sambuc while (__first != __last) 1755*4684ddb6SLionel Sambuc *--__result = *--__last; 1756*4684ddb6SLionel Sambuc return __result; 1757*4684ddb6SLionel Sambuc} 1758*4684ddb6SLionel Sambuc 1759*4684ddb6SLionel Sambuctemplate <class _Tp, class _Up> 1760*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1761*4684ddb6SLionel Sambuctypename enable_if 1762*4684ddb6SLionel Sambuc< 1763*4684ddb6SLionel Sambuc is_same<typename remove_const<_Tp>::type, _Up>::value && 1764*4684ddb6SLionel Sambuc is_trivially_copy_assignable<_Up>::value, 1765*4684ddb6SLionel Sambuc _Up* 1766*4684ddb6SLionel Sambuc>::type 1767*4684ddb6SLionel Sambuc__copy_backward(_Tp* __first, _Tp* __last, _Up* __result) 1768*4684ddb6SLionel Sambuc{ 1769*4684ddb6SLionel Sambuc const size_t __n = static_cast<size_t>(__last - __first); 1770*4684ddb6SLionel Sambuc __result -= __n; 1771*4684ddb6SLionel Sambuc _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1772*4684ddb6SLionel Sambuc return __result; 1773*4684ddb6SLionel Sambuc} 1774*4684ddb6SLionel Sambuc 1775*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 1776*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1777*4684ddb6SLionel Sambuc_BidirectionalIterator2 1778*4684ddb6SLionel Sambuccopy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 1779*4684ddb6SLionel Sambuc _BidirectionalIterator2 __result) 1780*4684ddb6SLionel Sambuc{ 1781*4684ddb6SLionel Sambuc return _VSTD::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1782*4684ddb6SLionel Sambuc} 1783*4684ddb6SLionel Sambuc 1784*4684ddb6SLionel Sambuc// copy_if 1785*4684ddb6SLionel Sambuc 1786*4684ddb6SLionel Sambuctemplate<class _InputIterator, class _OutputIterator, class _Predicate> 1787*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1788*4684ddb6SLionel Sambuc_OutputIterator 1789*4684ddb6SLionel Sambuccopy_if(_InputIterator __first, _InputIterator __last, 1790*4684ddb6SLionel Sambuc _OutputIterator __result, _Predicate __pred) 1791*4684ddb6SLionel Sambuc{ 1792*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 1793*4684ddb6SLionel Sambuc { 1794*4684ddb6SLionel Sambuc if (__pred(*__first)) 1795*4684ddb6SLionel Sambuc { 1796*4684ddb6SLionel Sambuc *__result = *__first; 1797*4684ddb6SLionel Sambuc ++__result; 1798*4684ddb6SLionel Sambuc } 1799*4684ddb6SLionel Sambuc } 1800*4684ddb6SLionel Sambuc return __result; 1801*4684ddb6SLionel Sambuc} 1802*4684ddb6SLionel Sambuc 1803*4684ddb6SLionel Sambuc// copy_n 1804*4684ddb6SLionel Sambuc 1805*4684ddb6SLionel Sambuctemplate<class _InputIterator, class _Size, class _OutputIterator> 1806*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1807*4684ddb6SLionel Sambuctypename enable_if 1808*4684ddb6SLionel Sambuc< 1809*4684ddb6SLionel Sambuc __is_input_iterator<_InputIterator>::value && 1810*4684ddb6SLionel Sambuc !__is_random_access_iterator<_InputIterator>::value, 1811*4684ddb6SLionel Sambuc _OutputIterator 1812*4684ddb6SLionel Sambuc>::type 1813*4684ddb6SLionel Sambuccopy_n(_InputIterator __first, _Size __n, _OutputIterator __result) 1814*4684ddb6SLionel Sambuc{ 1815*4684ddb6SLionel Sambuc if (__n > 0) 1816*4684ddb6SLionel Sambuc { 1817*4684ddb6SLionel Sambuc *__result = *__first; 1818*4684ddb6SLionel Sambuc ++__result; 1819*4684ddb6SLionel Sambuc for (--__n; __n > 0; --__n) 1820*4684ddb6SLionel Sambuc { 1821*4684ddb6SLionel Sambuc ++__first; 1822*4684ddb6SLionel Sambuc *__result = *__first; 1823*4684ddb6SLionel Sambuc ++__result; 1824*4684ddb6SLionel Sambuc } 1825*4684ddb6SLionel Sambuc } 1826*4684ddb6SLionel Sambuc return __result; 1827*4684ddb6SLionel Sambuc} 1828*4684ddb6SLionel Sambuc 1829*4684ddb6SLionel Sambuctemplate<class _InputIterator, class _Size, class _OutputIterator> 1830*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1831*4684ddb6SLionel Sambuctypename enable_if 1832*4684ddb6SLionel Sambuc< 1833*4684ddb6SLionel Sambuc __is_random_access_iterator<_InputIterator>::value, 1834*4684ddb6SLionel Sambuc _OutputIterator 1835*4684ddb6SLionel Sambuc>::type 1836*4684ddb6SLionel Sambuccopy_n(_InputIterator __first, _Size __n, _OutputIterator __result) 1837*4684ddb6SLionel Sambuc{ 1838*4684ddb6SLionel Sambuc return _VSTD::copy(__first, __first + __n, __result); 1839*4684ddb6SLionel Sambuc} 1840*4684ddb6SLionel Sambuc 1841*4684ddb6SLionel Sambuc// move 1842*4684ddb6SLionel Sambuc 1843*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator> 1844*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1845*4684ddb6SLionel Sambuc_OutputIterator 1846*4684ddb6SLionel Sambuc__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1847*4684ddb6SLionel Sambuc{ 1848*4684ddb6SLionel Sambuc for (; __first != __last; ++__first, ++__result) 1849*4684ddb6SLionel Sambuc *__result = _VSTD::move(*__first); 1850*4684ddb6SLionel Sambuc return __result; 1851*4684ddb6SLionel Sambuc} 1852*4684ddb6SLionel Sambuc 1853*4684ddb6SLionel Sambuctemplate <class _Tp, class _Up> 1854*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1855*4684ddb6SLionel Sambuctypename enable_if 1856*4684ddb6SLionel Sambuc< 1857*4684ddb6SLionel Sambuc is_same<typename remove_const<_Tp>::type, _Up>::value && 1858*4684ddb6SLionel Sambuc is_trivially_copy_assignable<_Up>::value, 1859*4684ddb6SLionel Sambuc _Up* 1860*4684ddb6SLionel Sambuc>::type 1861*4684ddb6SLionel Sambuc__move(_Tp* __first, _Tp* __last, _Up* __result) 1862*4684ddb6SLionel Sambuc{ 1863*4684ddb6SLionel Sambuc const size_t __n = static_cast<size_t>(__last - __first); 1864*4684ddb6SLionel Sambuc _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1865*4684ddb6SLionel Sambuc return __result + __n; 1866*4684ddb6SLionel Sambuc} 1867*4684ddb6SLionel Sambuc 1868*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator> 1869*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1870*4684ddb6SLionel Sambuc_OutputIterator 1871*4684ddb6SLionel Sambucmove(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1872*4684ddb6SLionel Sambuc{ 1873*4684ddb6SLionel Sambuc return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1874*4684ddb6SLionel Sambuc} 1875*4684ddb6SLionel Sambuc 1876*4684ddb6SLionel Sambuc// move_backward 1877*4684ddb6SLionel Sambuc 1878*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator> 1879*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1880*4684ddb6SLionel Sambuc_OutputIterator 1881*4684ddb6SLionel Sambuc__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 1882*4684ddb6SLionel Sambuc{ 1883*4684ddb6SLionel Sambuc while (__first != __last) 1884*4684ddb6SLionel Sambuc *--__result = _VSTD::move(*--__last); 1885*4684ddb6SLionel Sambuc return __result; 1886*4684ddb6SLionel Sambuc} 1887*4684ddb6SLionel Sambuc 1888*4684ddb6SLionel Sambuctemplate <class _Tp, class _Up> 1889*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1890*4684ddb6SLionel Sambuctypename enable_if 1891*4684ddb6SLionel Sambuc< 1892*4684ddb6SLionel Sambuc is_same<typename remove_const<_Tp>::type, _Up>::value && 1893*4684ddb6SLionel Sambuc is_trivially_copy_assignable<_Up>::value, 1894*4684ddb6SLionel Sambuc _Up* 1895*4684ddb6SLionel Sambuc>::type 1896*4684ddb6SLionel Sambuc__move_backward(_Tp* __first, _Tp* __last, _Up* __result) 1897*4684ddb6SLionel Sambuc{ 1898*4684ddb6SLionel Sambuc const size_t __n = static_cast<size_t>(__last - __first); 1899*4684ddb6SLionel Sambuc __result -= __n; 1900*4684ddb6SLionel Sambuc _VSTD::memmove(__result, __first, __n * sizeof(_Up)); 1901*4684ddb6SLionel Sambuc return __result; 1902*4684ddb6SLionel Sambuc} 1903*4684ddb6SLionel Sambuc 1904*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator1, class _BidirectionalIterator2> 1905*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1906*4684ddb6SLionel Sambuc_BidirectionalIterator2 1907*4684ddb6SLionel Sambucmove_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 1908*4684ddb6SLionel Sambuc _BidirectionalIterator2 __result) 1909*4684ddb6SLionel Sambuc{ 1910*4684ddb6SLionel Sambuc return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); 1911*4684ddb6SLionel Sambuc} 1912*4684ddb6SLionel Sambuc 1913*4684ddb6SLionel Sambuc// iter_swap 1914*4684ddb6SLionel Sambuc 1915*4684ddb6SLionel Sambuc// moved to <type_traits> for better swap / noexcept support 1916*4684ddb6SLionel Sambuc 1917*4684ddb6SLionel Sambuc// transform 1918*4684ddb6SLionel Sambuc 1919*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator, class _UnaryOperation> 1920*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1921*4684ddb6SLionel Sambuc_OutputIterator 1922*4684ddb6SLionel Sambuctransform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) 1923*4684ddb6SLionel Sambuc{ 1924*4684ddb6SLionel Sambuc for (; __first != __last; ++__first, ++__result) 1925*4684ddb6SLionel Sambuc *__result = __op(*__first); 1926*4684ddb6SLionel Sambuc return __result; 1927*4684ddb6SLionel Sambuc} 1928*4684ddb6SLionel Sambuc 1929*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation> 1930*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1931*4684ddb6SLionel Sambuc_OutputIterator 1932*4684ddb6SLionel Sambuctransform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, 1933*4684ddb6SLionel Sambuc _OutputIterator __result, _BinaryOperation __binary_op) 1934*4684ddb6SLionel Sambuc{ 1935*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1, ++__first2, ++__result) 1936*4684ddb6SLionel Sambuc *__result = __binary_op(*__first1, *__first2); 1937*4684ddb6SLionel Sambuc return __result; 1938*4684ddb6SLionel Sambuc} 1939*4684ddb6SLionel Sambuc 1940*4684ddb6SLionel Sambuc// replace 1941*4684ddb6SLionel Sambuc 1942*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 1943*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1944*4684ddb6SLionel Sambucvoid 1945*4684ddb6SLionel Sambucreplace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) 1946*4684ddb6SLionel Sambuc{ 1947*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 1948*4684ddb6SLionel Sambuc if (*__first == __old_value) 1949*4684ddb6SLionel Sambuc *__first = __new_value; 1950*4684ddb6SLionel Sambuc} 1951*4684ddb6SLionel Sambuc 1952*4684ddb6SLionel Sambuc// replace_if 1953*4684ddb6SLionel Sambuc 1954*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Predicate, class _Tp> 1955*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1956*4684ddb6SLionel Sambucvoid 1957*4684ddb6SLionel Sambucreplace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) 1958*4684ddb6SLionel Sambuc{ 1959*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 1960*4684ddb6SLionel Sambuc if (__pred(*__first)) 1961*4684ddb6SLionel Sambuc *__first = __new_value; 1962*4684ddb6SLionel Sambuc} 1963*4684ddb6SLionel Sambuc 1964*4684ddb6SLionel Sambuc// replace_copy 1965*4684ddb6SLionel Sambuc 1966*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator, class _Tp> 1967*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1968*4684ddb6SLionel Sambuc_OutputIterator 1969*4684ddb6SLionel Sambucreplace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 1970*4684ddb6SLionel Sambuc const _Tp& __old_value, const _Tp& __new_value) 1971*4684ddb6SLionel Sambuc{ 1972*4684ddb6SLionel Sambuc for (; __first != __last; ++__first, ++__result) 1973*4684ddb6SLionel Sambuc if (*__first == __old_value) 1974*4684ddb6SLionel Sambuc *__result = __new_value; 1975*4684ddb6SLionel Sambuc else 1976*4684ddb6SLionel Sambuc *__result = *__first; 1977*4684ddb6SLionel Sambuc return __result; 1978*4684ddb6SLionel Sambuc} 1979*4684ddb6SLionel Sambuc 1980*4684ddb6SLionel Sambuc// replace_copy_if 1981*4684ddb6SLionel Sambuc 1982*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp> 1983*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 1984*4684ddb6SLionel Sambuc_OutputIterator 1985*4684ddb6SLionel Sambucreplace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, 1986*4684ddb6SLionel Sambuc _Predicate __pred, const _Tp& __new_value) 1987*4684ddb6SLionel Sambuc{ 1988*4684ddb6SLionel Sambuc for (; __first != __last; ++__first, ++__result) 1989*4684ddb6SLionel Sambuc if (__pred(*__first)) 1990*4684ddb6SLionel Sambuc *__result = __new_value; 1991*4684ddb6SLionel Sambuc else 1992*4684ddb6SLionel Sambuc *__result = *__first; 1993*4684ddb6SLionel Sambuc return __result; 1994*4684ddb6SLionel Sambuc} 1995*4684ddb6SLionel Sambuc 1996*4684ddb6SLionel Sambuc// fill_n 1997*4684ddb6SLionel Sambuc 1998*4684ddb6SLionel Sambuctemplate <class _OutputIterator, class _Size, class _Tp> 1999*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2000*4684ddb6SLionel Sambuc_OutputIterator 2001*4684ddb6SLionel Sambuc__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 2002*4684ddb6SLionel Sambuc{ 2003*4684ddb6SLionel Sambuc for (; __n > 0; ++__first, --__n) 2004*4684ddb6SLionel Sambuc *__first = __value_; 2005*4684ddb6SLionel Sambuc return __first; 2006*4684ddb6SLionel Sambuc} 2007*4684ddb6SLionel Sambuc 2008*4684ddb6SLionel Sambuctemplate <class _Tp, class _Size, class _Up> 2009*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2010*4684ddb6SLionel Sambuctypename enable_if 2011*4684ddb6SLionel Sambuc< 2012*4684ddb6SLionel Sambuc is_integral<_Tp>::value && sizeof(_Tp) == 1 && 2013*4684ddb6SLionel Sambuc !is_same<_Tp, bool>::value && 2014*4684ddb6SLionel Sambuc is_integral<_Up>::value && sizeof(_Up) == 1, 2015*4684ddb6SLionel Sambuc _Tp* 2016*4684ddb6SLionel Sambuc>::type 2017*4684ddb6SLionel Sambuc__fill_n(_Tp* __first, _Size __n,_Up __value_) 2018*4684ddb6SLionel Sambuc{ 2019*4684ddb6SLionel Sambuc if (__n > 0) 2020*4684ddb6SLionel Sambuc _VSTD::memset(__first, (unsigned char)__value_, (size_t)(__n)); 2021*4684ddb6SLionel Sambuc return __first + __n; 2022*4684ddb6SLionel Sambuc} 2023*4684ddb6SLionel Sambuc 2024*4684ddb6SLionel Sambuctemplate <class _OutputIterator, class _Size, class _Tp> 2025*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2026*4684ddb6SLionel Sambuc_OutputIterator 2027*4684ddb6SLionel Sambucfill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) 2028*4684ddb6SLionel Sambuc{ 2029*4684ddb6SLionel Sambuc return _VSTD::__fill_n(__first, __n, __value_); 2030*4684ddb6SLionel Sambuc} 2031*4684ddb6SLionel Sambuc 2032*4684ddb6SLionel Sambuc// fill 2033*4684ddb6SLionel Sambuc 2034*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 2035*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2036*4684ddb6SLionel Sambucvoid 2037*4684ddb6SLionel Sambuc__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag) 2038*4684ddb6SLionel Sambuc{ 2039*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 2040*4684ddb6SLionel Sambuc *__first = __value_; 2041*4684ddb6SLionel Sambuc} 2042*4684ddb6SLionel Sambuc 2043*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Tp> 2044*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2045*4684ddb6SLionel Sambucvoid 2046*4684ddb6SLionel Sambuc__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag) 2047*4684ddb6SLionel Sambuc{ 2048*4684ddb6SLionel Sambuc _VSTD::fill_n(__first, __last - __first, __value_); 2049*4684ddb6SLionel Sambuc} 2050*4684ddb6SLionel Sambuc 2051*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 2052*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2053*4684ddb6SLionel Sambucvoid 2054*4684ddb6SLionel Sambucfill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 2055*4684ddb6SLionel Sambuc{ 2056*4684ddb6SLionel Sambuc _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category()); 2057*4684ddb6SLionel Sambuc} 2058*4684ddb6SLionel Sambuc 2059*4684ddb6SLionel Sambuc// generate 2060*4684ddb6SLionel Sambuc 2061*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Generator> 2062*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2063*4684ddb6SLionel Sambucvoid 2064*4684ddb6SLionel Sambucgenerate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) 2065*4684ddb6SLionel Sambuc{ 2066*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 2067*4684ddb6SLionel Sambuc *__first = __gen(); 2068*4684ddb6SLionel Sambuc} 2069*4684ddb6SLionel Sambuc 2070*4684ddb6SLionel Sambuc// generate_n 2071*4684ddb6SLionel Sambuc 2072*4684ddb6SLionel Sambuctemplate <class _OutputIterator, class _Size, class _Generator> 2073*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2074*4684ddb6SLionel Sambuc_OutputIterator 2075*4684ddb6SLionel Sambucgenerate_n(_OutputIterator __first, _Size __n, _Generator __gen) 2076*4684ddb6SLionel Sambuc{ 2077*4684ddb6SLionel Sambuc for (; __n > 0; ++__first, --__n) 2078*4684ddb6SLionel Sambuc *__first = __gen(); 2079*4684ddb6SLionel Sambuc return __first; 2080*4684ddb6SLionel Sambuc} 2081*4684ddb6SLionel Sambuc 2082*4684ddb6SLionel Sambuc// remove 2083*4684ddb6SLionel Sambuc 2084*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 2085*4684ddb6SLionel Sambuc_ForwardIterator 2086*4684ddb6SLionel Sambucremove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 2087*4684ddb6SLionel Sambuc{ 2088*4684ddb6SLionel Sambuc __first = _VSTD::find(__first, __last, __value_); 2089*4684ddb6SLionel Sambuc if (__first != __last) 2090*4684ddb6SLionel Sambuc { 2091*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2092*4684ddb6SLionel Sambuc while (++__i != __last) 2093*4684ddb6SLionel Sambuc { 2094*4684ddb6SLionel Sambuc if (!(*__i == __value_)) 2095*4684ddb6SLionel Sambuc { 2096*4684ddb6SLionel Sambuc *__first = _VSTD::move(*__i); 2097*4684ddb6SLionel Sambuc ++__first; 2098*4684ddb6SLionel Sambuc } 2099*4684ddb6SLionel Sambuc } 2100*4684ddb6SLionel Sambuc } 2101*4684ddb6SLionel Sambuc return __first; 2102*4684ddb6SLionel Sambuc} 2103*4684ddb6SLionel Sambuc 2104*4684ddb6SLionel Sambuc// remove_if 2105*4684ddb6SLionel Sambuc 2106*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Predicate> 2107*4684ddb6SLionel Sambuc_ForwardIterator 2108*4684ddb6SLionel Sambucremove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 2109*4684ddb6SLionel Sambuc{ 2110*4684ddb6SLionel Sambuc __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type> 2111*4684ddb6SLionel Sambuc (__first, __last, __pred); 2112*4684ddb6SLionel Sambuc if (__first != __last) 2113*4684ddb6SLionel Sambuc { 2114*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2115*4684ddb6SLionel Sambuc while (++__i != __last) 2116*4684ddb6SLionel Sambuc { 2117*4684ddb6SLionel Sambuc if (!__pred(*__i)) 2118*4684ddb6SLionel Sambuc { 2119*4684ddb6SLionel Sambuc *__first = _VSTD::move(*__i); 2120*4684ddb6SLionel Sambuc ++__first; 2121*4684ddb6SLionel Sambuc } 2122*4684ddb6SLionel Sambuc } 2123*4684ddb6SLionel Sambuc } 2124*4684ddb6SLionel Sambuc return __first; 2125*4684ddb6SLionel Sambuc} 2126*4684ddb6SLionel Sambuc 2127*4684ddb6SLionel Sambuc// remove_copy 2128*4684ddb6SLionel Sambuc 2129*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator, class _Tp> 2130*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2131*4684ddb6SLionel Sambuc_OutputIterator 2132*4684ddb6SLionel Sambucremove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_) 2133*4684ddb6SLionel Sambuc{ 2134*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 2135*4684ddb6SLionel Sambuc { 2136*4684ddb6SLionel Sambuc if (!(*__first == __value_)) 2137*4684ddb6SLionel Sambuc { 2138*4684ddb6SLionel Sambuc *__result = *__first; 2139*4684ddb6SLionel Sambuc ++__result; 2140*4684ddb6SLionel Sambuc } 2141*4684ddb6SLionel Sambuc } 2142*4684ddb6SLionel Sambuc return __result; 2143*4684ddb6SLionel Sambuc} 2144*4684ddb6SLionel Sambuc 2145*4684ddb6SLionel Sambuc// remove_copy_if 2146*4684ddb6SLionel Sambuc 2147*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator, class _Predicate> 2148*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2149*4684ddb6SLionel Sambuc_OutputIterator 2150*4684ddb6SLionel Sambucremove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) 2151*4684ddb6SLionel Sambuc{ 2152*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 2153*4684ddb6SLionel Sambuc { 2154*4684ddb6SLionel Sambuc if (!__pred(*__first)) 2155*4684ddb6SLionel Sambuc { 2156*4684ddb6SLionel Sambuc *__result = *__first; 2157*4684ddb6SLionel Sambuc ++__result; 2158*4684ddb6SLionel Sambuc } 2159*4684ddb6SLionel Sambuc } 2160*4684ddb6SLionel Sambuc return __result; 2161*4684ddb6SLionel Sambuc} 2162*4684ddb6SLionel Sambuc 2163*4684ddb6SLionel Sambuc// unique 2164*4684ddb6SLionel Sambuc 2165*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _BinaryPredicate> 2166*4684ddb6SLionel Sambuc_ForwardIterator 2167*4684ddb6SLionel Sambucunique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) 2168*4684ddb6SLionel Sambuc{ 2169*4684ddb6SLionel Sambuc __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type> 2170*4684ddb6SLionel Sambuc (__first, __last, __pred); 2171*4684ddb6SLionel Sambuc if (__first != __last) 2172*4684ddb6SLionel Sambuc { 2173*4684ddb6SLionel Sambuc // ... a a ? ... 2174*4684ddb6SLionel Sambuc // f i 2175*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2176*4684ddb6SLionel Sambuc for (++__i; ++__i != __last;) 2177*4684ddb6SLionel Sambuc if (!__pred(*__first, *__i)) 2178*4684ddb6SLionel Sambuc *++__first = _VSTD::move(*__i); 2179*4684ddb6SLionel Sambuc ++__first; 2180*4684ddb6SLionel Sambuc } 2181*4684ddb6SLionel Sambuc return __first; 2182*4684ddb6SLionel Sambuc} 2183*4684ddb6SLionel Sambuc 2184*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2185*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2186*4684ddb6SLionel Sambuc_ForwardIterator 2187*4684ddb6SLionel Sambucunique(_ForwardIterator __first, _ForwardIterator __last) 2188*4684ddb6SLionel Sambuc{ 2189*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::value_type __v; 2190*4684ddb6SLionel Sambuc return _VSTD::unique(__first, __last, __equal_to<__v>()); 2191*4684ddb6SLionel Sambuc} 2192*4684ddb6SLionel Sambuc 2193*4684ddb6SLionel Sambuc// unique_copy 2194*4684ddb6SLionel Sambuc 2195*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _InputIterator, class _OutputIterator> 2196*4684ddb6SLionel Sambuc_OutputIterator 2197*4684ddb6SLionel Sambuc__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 2198*4684ddb6SLionel Sambuc input_iterator_tag, output_iterator_tag) 2199*4684ddb6SLionel Sambuc{ 2200*4684ddb6SLionel Sambuc if (__first != __last) 2201*4684ddb6SLionel Sambuc { 2202*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator>::value_type __t(*__first); 2203*4684ddb6SLionel Sambuc *__result = __t; 2204*4684ddb6SLionel Sambuc ++__result; 2205*4684ddb6SLionel Sambuc while (++__first != __last) 2206*4684ddb6SLionel Sambuc { 2207*4684ddb6SLionel Sambuc if (!__pred(__t, *__first)) 2208*4684ddb6SLionel Sambuc { 2209*4684ddb6SLionel Sambuc __t = *__first; 2210*4684ddb6SLionel Sambuc *__result = __t; 2211*4684ddb6SLionel Sambuc ++__result; 2212*4684ddb6SLionel Sambuc } 2213*4684ddb6SLionel Sambuc } 2214*4684ddb6SLionel Sambuc } 2215*4684ddb6SLionel Sambuc return __result; 2216*4684ddb6SLionel Sambuc} 2217*4684ddb6SLionel Sambuc 2218*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator> 2219*4684ddb6SLionel Sambuc_OutputIterator 2220*4684ddb6SLionel Sambuc__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred, 2221*4684ddb6SLionel Sambuc forward_iterator_tag, output_iterator_tag) 2222*4684ddb6SLionel Sambuc{ 2223*4684ddb6SLionel Sambuc if (__first != __last) 2224*4684ddb6SLionel Sambuc { 2225*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2226*4684ddb6SLionel Sambuc *__result = *__i; 2227*4684ddb6SLionel Sambuc ++__result; 2228*4684ddb6SLionel Sambuc while (++__first != __last) 2229*4684ddb6SLionel Sambuc { 2230*4684ddb6SLionel Sambuc if (!__pred(*__i, *__first)) 2231*4684ddb6SLionel Sambuc { 2232*4684ddb6SLionel Sambuc *__result = *__first; 2233*4684ddb6SLionel Sambuc ++__result; 2234*4684ddb6SLionel Sambuc __i = __first; 2235*4684ddb6SLionel Sambuc } 2236*4684ddb6SLionel Sambuc } 2237*4684ddb6SLionel Sambuc } 2238*4684ddb6SLionel Sambuc return __result; 2239*4684ddb6SLionel Sambuc} 2240*4684ddb6SLionel Sambuc 2241*4684ddb6SLionel Sambuctemplate <class _BinaryPredicate, class _InputIterator, class _ForwardIterator> 2242*4684ddb6SLionel Sambuc_ForwardIterator 2243*4684ddb6SLionel Sambuc__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred, 2244*4684ddb6SLionel Sambuc input_iterator_tag, forward_iterator_tag) 2245*4684ddb6SLionel Sambuc{ 2246*4684ddb6SLionel Sambuc if (__first != __last) 2247*4684ddb6SLionel Sambuc { 2248*4684ddb6SLionel Sambuc *__result = *__first; 2249*4684ddb6SLionel Sambuc while (++__first != __last) 2250*4684ddb6SLionel Sambuc if (!__pred(*__result, *__first)) 2251*4684ddb6SLionel Sambuc *++__result = *__first; 2252*4684ddb6SLionel Sambuc ++__result; 2253*4684ddb6SLionel Sambuc } 2254*4684ddb6SLionel Sambuc return __result; 2255*4684ddb6SLionel Sambuc} 2256*4684ddb6SLionel Sambuc 2257*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator, class _BinaryPredicate> 2258*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2259*4684ddb6SLionel Sambuc_OutputIterator 2260*4684ddb6SLionel Sambucunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) 2261*4684ddb6SLionel Sambuc{ 2262*4684ddb6SLionel Sambuc return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type> 2263*4684ddb6SLionel Sambuc (__first, __last, __result, __pred, 2264*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator>::iterator_category(), 2265*4684ddb6SLionel Sambuc typename iterator_traits<_OutputIterator>::iterator_category()); 2266*4684ddb6SLionel Sambuc} 2267*4684ddb6SLionel Sambuc 2268*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator> 2269*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2270*4684ddb6SLionel Sambuc_OutputIterator 2271*4684ddb6SLionel Sambucunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) 2272*4684ddb6SLionel Sambuc{ 2273*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator>::value_type __v; 2274*4684ddb6SLionel Sambuc return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>()); 2275*4684ddb6SLionel Sambuc} 2276*4684ddb6SLionel Sambuc 2277*4684ddb6SLionel Sambuc// reverse 2278*4684ddb6SLionel Sambuc 2279*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 2280*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2281*4684ddb6SLionel Sambucvoid 2282*4684ddb6SLionel Sambuc__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) 2283*4684ddb6SLionel Sambuc{ 2284*4684ddb6SLionel Sambuc while (__first != __last) 2285*4684ddb6SLionel Sambuc { 2286*4684ddb6SLionel Sambuc if (__first == --__last) 2287*4684ddb6SLionel Sambuc break; 2288*4684ddb6SLionel Sambuc swap(*__first, *__last); 2289*4684ddb6SLionel Sambuc ++__first; 2290*4684ddb6SLionel Sambuc } 2291*4684ddb6SLionel Sambuc} 2292*4684ddb6SLionel Sambuc 2293*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 2294*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2295*4684ddb6SLionel Sambucvoid 2296*4684ddb6SLionel Sambuc__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) 2297*4684ddb6SLionel Sambuc{ 2298*4684ddb6SLionel Sambuc if (__first != __last) 2299*4684ddb6SLionel Sambuc for (; __first < --__last; ++__first) 2300*4684ddb6SLionel Sambuc swap(*__first, *__last); 2301*4684ddb6SLionel Sambuc} 2302*4684ddb6SLionel Sambuc 2303*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 2304*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2305*4684ddb6SLionel Sambucvoid 2306*4684ddb6SLionel Sambucreverse(_BidirectionalIterator __first, _BidirectionalIterator __last) 2307*4684ddb6SLionel Sambuc{ 2308*4684ddb6SLionel Sambuc _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category()); 2309*4684ddb6SLionel Sambuc} 2310*4684ddb6SLionel Sambuc 2311*4684ddb6SLionel Sambuc// reverse_copy 2312*4684ddb6SLionel Sambuc 2313*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator, class _OutputIterator> 2314*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2315*4684ddb6SLionel Sambuc_OutputIterator 2316*4684ddb6SLionel Sambucreverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) 2317*4684ddb6SLionel Sambuc{ 2318*4684ddb6SLionel Sambuc for (; __first != __last; ++__result) 2319*4684ddb6SLionel Sambuc *__result = *--__last; 2320*4684ddb6SLionel Sambuc return __result; 2321*4684ddb6SLionel Sambuc} 2322*4684ddb6SLionel Sambuc 2323*4684ddb6SLionel Sambuc// rotate 2324*4684ddb6SLionel Sambuc 2325*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2326*4684ddb6SLionel Sambuc_ForwardIterator 2327*4684ddb6SLionel Sambuc__rotate_left(_ForwardIterator __first, _ForwardIterator __last) 2328*4684ddb6SLionel Sambuc{ 2329*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 2330*4684ddb6SLionel Sambuc value_type __tmp = _VSTD::move(*__first); 2331*4684ddb6SLionel Sambuc _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first); 2332*4684ddb6SLionel Sambuc *__lm1 = _VSTD::move(__tmp); 2333*4684ddb6SLionel Sambuc return __lm1; 2334*4684ddb6SLionel Sambuc} 2335*4684ddb6SLionel Sambuc 2336*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 2337*4684ddb6SLionel Sambuc_BidirectionalIterator 2338*4684ddb6SLionel Sambuc__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) 2339*4684ddb6SLionel Sambuc{ 2340*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 2341*4684ddb6SLionel Sambuc _BidirectionalIterator __lm1 = _VSTD::prev(__last); 2342*4684ddb6SLionel Sambuc value_type __tmp = _VSTD::move(*__lm1); 2343*4684ddb6SLionel Sambuc _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last); 2344*4684ddb6SLionel Sambuc *__first = _VSTD::move(__tmp); 2345*4684ddb6SLionel Sambuc return __fp1; 2346*4684ddb6SLionel Sambuc} 2347*4684ddb6SLionel Sambuc 2348*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2349*4684ddb6SLionel Sambuc_ForwardIterator 2350*4684ddb6SLionel Sambuc__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 2351*4684ddb6SLionel Sambuc{ 2352*4684ddb6SLionel Sambuc _ForwardIterator __i = __middle; 2353*4684ddb6SLionel Sambuc while (true) 2354*4684ddb6SLionel Sambuc { 2355*4684ddb6SLionel Sambuc swap(*__first, *__i); 2356*4684ddb6SLionel Sambuc ++__first; 2357*4684ddb6SLionel Sambuc if (++__i == __last) 2358*4684ddb6SLionel Sambuc break; 2359*4684ddb6SLionel Sambuc if (__first == __middle) 2360*4684ddb6SLionel Sambuc __middle = __i; 2361*4684ddb6SLionel Sambuc } 2362*4684ddb6SLionel Sambuc _ForwardIterator __r = __first; 2363*4684ddb6SLionel Sambuc if (__first != __middle) 2364*4684ddb6SLionel Sambuc { 2365*4684ddb6SLionel Sambuc __i = __middle; 2366*4684ddb6SLionel Sambuc while (true) 2367*4684ddb6SLionel Sambuc { 2368*4684ddb6SLionel Sambuc swap(*__first, *__i); 2369*4684ddb6SLionel Sambuc ++__first; 2370*4684ddb6SLionel Sambuc if (++__i == __last) 2371*4684ddb6SLionel Sambuc { 2372*4684ddb6SLionel Sambuc if (__first == __middle) 2373*4684ddb6SLionel Sambuc break; 2374*4684ddb6SLionel Sambuc __i = __middle; 2375*4684ddb6SLionel Sambuc } 2376*4684ddb6SLionel Sambuc else if (__first == __middle) 2377*4684ddb6SLionel Sambuc __middle = __i; 2378*4684ddb6SLionel Sambuc } 2379*4684ddb6SLionel Sambuc } 2380*4684ddb6SLionel Sambuc return __r; 2381*4684ddb6SLionel Sambuc} 2382*4684ddb6SLionel Sambuc 2383*4684ddb6SLionel Sambuctemplate<typename _Integral> 2384*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2385*4684ddb6SLionel Sambuc_Integral 2386*4684ddb6SLionel Sambuc__gcd(_Integral __x, _Integral __y) 2387*4684ddb6SLionel Sambuc{ 2388*4684ddb6SLionel Sambuc do 2389*4684ddb6SLionel Sambuc { 2390*4684ddb6SLionel Sambuc _Integral __t = __x % __y; 2391*4684ddb6SLionel Sambuc __x = __y; 2392*4684ddb6SLionel Sambuc __y = __t; 2393*4684ddb6SLionel Sambuc } while (__y); 2394*4684ddb6SLionel Sambuc return __x; 2395*4684ddb6SLionel Sambuc} 2396*4684ddb6SLionel Sambuc 2397*4684ddb6SLionel Sambuctemplate<typename _RandomAccessIterator> 2398*4684ddb6SLionel Sambuc_RandomAccessIterator 2399*4684ddb6SLionel Sambuc__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 2400*4684ddb6SLionel Sambuc{ 2401*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 2402*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 2403*4684ddb6SLionel Sambuc 2404*4684ddb6SLionel Sambuc const difference_type __m1 = __middle - __first; 2405*4684ddb6SLionel Sambuc const difference_type __m2 = __last - __middle; 2406*4684ddb6SLionel Sambuc if (__m1 == __m2) 2407*4684ddb6SLionel Sambuc { 2408*4684ddb6SLionel Sambuc _VSTD::swap_ranges(__first, __middle, __middle); 2409*4684ddb6SLionel Sambuc return __middle; 2410*4684ddb6SLionel Sambuc } 2411*4684ddb6SLionel Sambuc const difference_type __g = _VSTD::__gcd(__m1, __m2); 2412*4684ddb6SLionel Sambuc for (_RandomAccessIterator __p = __first + __g; __p != __first;) 2413*4684ddb6SLionel Sambuc { 2414*4684ddb6SLionel Sambuc value_type __t(_VSTD::move(*--__p)); 2415*4684ddb6SLionel Sambuc _RandomAccessIterator __p1 = __p; 2416*4684ddb6SLionel Sambuc _RandomAccessIterator __p2 = __p1 + __m1; 2417*4684ddb6SLionel Sambuc do 2418*4684ddb6SLionel Sambuc { 2419*4684ddb6SLionel Sambuc *__p1 = _VSTD::move(*__p2); 2420*4684ddb6SLionel Sambuc __p1 = __p2; 2421*4684ddb6SLionel Sambuc const difference_type __d = __last - __p2; 2422*4684ddb6SLionel Sambuc if (__m1 < __d) 2423*4684ddb6SLionel Sambuc __p2 += __m1; 2424*4684ddb6SLionel Sambuc else 2425*4684ddb6SLionel Sambuc __p2 = __first + (__m1 - __d); 2426*4684ddb6SLionel Sambuc } while (__p2 != __p); 2427*4684ddb6SLionel Sambuc *__p1 = _VSTD::move(__t); 2428*4684ddb6SLionel Sambuc } 2429*4684ddb6SLionel Sambuc return __first + __m2; 2430*4684ddb6SLionel Sambuc} 2431*4684ddb6SLionel Sambuc 2432*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2433*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2434*4684ddb6SLionel Sambuc_ForwardIterator 2435*4684ddb6SLionel Sambuc__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, 2436*4684ddb6SLionel Sambuc _VSTD::forward_iterator_tag) 2437*4684ddb6SLionel Sambuc{ 2438*4684ddb6SLionel Sambuc typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type; 2439*4684ddb6SLionel Sambuc if (_VSTD::is_trivially_move_assignable<value_type>::value) 2440*4684ddb6SLionel Sambuc { 2441*4684ddb6SLionel Sambuc if (_VSTD::next(__first) == __middle) 2442*4684ddb6SLionel Sambuc return _VSTD::__rotate_left(__first, __last); 2443*4684ddb6SLionel Sambuc } 2444*4684ddb6SLionel Sambuc return _VSTD::__rotate_forward(__first, __middle, __last); 2445*4684ddb6SLionel Sambuc} 2446*4684ddb6SLionel Sambuc 2447*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 2448*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2449*4684ddb6SLionel Sambuc_BidirectionalIterator 2450*4684ddb6SLionel Sambuc__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 2451*4684ddb6SLionel Sambuc _VSTD::bidirectional_iterator_tag) 2452*4684ddb6SLionel Sambuc{ 2453*4684ddb6SLionel Sambuc typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type; 2454*4684ddb6SLionel Sambuc if (_VSTD::is_trivially_move_assignable<value_type>::value) 2455*4684ddb6SLionel Sambuc { 2456*4684ddb6SLionel Sambuc if (_VSTD::next(__first) == __middle) 2457*4684ddb6SLionel Sambuc return _VSTD::__rotate_left(__first, __last); 2458*4684ddb6SLionel Sambuc if (_VSTD::next(__middle) == __last) 2459*4684ddb6SLionel Sambuc return _VSTD::__rotate_right(__first, __last); 2460*4684ddb6SLionel Sambuc } 2461*4684ddb6SLionel Sambuc return _VSTD::__rotate_forward(__first, __middle, __last); 2462*4684ddb6SLionel Sambuc} 2463*4684ddb6SLionel Sambuc 2464*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 2465*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2466*4684ddb6SLionel Sambuc_RandomAccessIterator 2467*4684ddb6SLionel Sambuc__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 2468*4684ddb6SLionel Sambuc _VSTD::random_access_iterator_tag) 2469*4684ddb6SLionel Sambuc{ 2470*4684ddb6SLionel Sambuc typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type; 2471*4684ddb6SLionel Sambuc if (_VSTD::is_trivially_move_assignable<value_type>::value) 2472*4684ddb6SLionel Sambuc { 2473*4684ddb6SLionel Sambuc if (_VSTD::next(__first) == __middle) 2474*4684ddb6SLionel Sambuc return _VSTD::__rotate_left(__first, __last); 2475*4684ddb6SLionel Sambuc if (_VSTD::next(__middle) == __last) 2476*4684ddb6SLionel Sambuc return _VSTD::__rotate_right(__first, __last); 2477*4684ddb6SLionel Sambuc return _VSTD::__rotate_gcd(__first, __middle, __last); 2478*4684ddb6SLionel Sambuc } 2479*4684ddb6SLionel Sambuc return _VSTD::__rotate_forward(__first, __middle, __last); 2480*4684ddb6SLionel Sambuc} 2481*4684ddb6SLionel Sambuc 2482*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2483*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2484*4684ddb6SLionel Sambuc_ForwardIterator 2485*4684ddb6SLionel Sambucrotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) 2486*4684ddb6SLionel Sambuc{ 2487*4684ddb6SLionel Sambuc if (__first == __middle) 2488*4684ddb6SLionel Sambuc return __last; 2489*4684ddb6SLionel Sambuc if (__middle == __last) 2490*4684ddb6SLionel Sambuc return __first; 2491*4684ddb6SLionel Sambuc return _VSTD::__rotate(__first, __middle, __last, 2492*4684ddb6SLionel Sambuc typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category()); 2493*4684ddb6SLionel Sambuc} 2494*4684ddb6SLionel Sambuc 2495*4684ddb6SLionel Sambuc// rotate_copy 2496*4684ddb6SLionel Sambuc 2497*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _OutputIterator> 2498*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2499*4684ddb6SLionel Sambuc_OutputIterator 2500*4684ddb6SLionel Sambucrotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) 2501*4684ddb6SLionel Sambuc{ 2502*4684ddb6SLionel Sambuc return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result)); 2503*4684ddb6SLionel Sambuc} 2504*4684ddb6SLionel Sambuc 2505*4684ddb6SLionel Sambuc// min_element 2506*4684ddb6SLionel Sambuc 2507*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Compare> 2508*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2509*4684ddb6SLionel Sambuc_ForwardIterator 2510*4684ddb6SLionel Sambucmin_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 2511*4684ddb6SLionel Sambuc{ 2512*4684ddb6SLionel Sambuc if (__first != __last) 2513*4684ddb6SLionel Sambuc { 2514*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2515*4684ddb6SLionel Sambuc while (++__i != __last) 2516*4684ddb6SLionel Sambuc if (__comp(*__i, *__first)) 2517*4684ddb6SLionel Sambuc __first = __i; 2518*4684ddb6SLionel Sambuc } 2519*4684ddb6SLionel Sambuc return __first; 2520*4684ddb6SLionel Sambuc} 2521*4684ddb6SLionel Sambuc 2522*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2523*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2524*4684ddb6SLionel Sambuc_ForwardIterator 2525*4684ddb6SLionel Sambucmin_element(_ForwardIterator __first, _ForwardIterator __last) 2526*4684ddb6SLionel Sambuc{ 2527*4684ddb6SLionel Sambuc return _VSTD::min_element(__first, __last, 2528*4684ddb6SLionel Sambuc __less<typename iterator_traits<_ForwardIterator>::value_type>()); 2529*4684ddb6SLionel Sambuc} 2530*4684ddb6SLionel Sambuc 2531*4684ddb6SLionel Sambuc// min 2532*4684ddb6SLionel Sambuc 2533*4684ddb6SLionel Sambuctemplate <class _Tp, class _Compare> 2534*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2535*4684ddb6SLionel Sambucconst _Tp& 2536*4684ddb6SLionel Sambucmin(const _Tp& __a, const _Tp& __b, _Compare __comp) 2537*4684ddb6SLionel Sambuc{ 2538*4684ddb6SLionel Sambuc return __comp(__b, __a) ? __b : __a; 2539*4684ddb6SLionel Sambuc} 2540*4684ddb6SLionel Sambuc 2541*4684ddb6SLionel Sambuctemplate <class _Tp> 2542*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2543*4684ddb6SLionel Sambucconst _Tp& 2544*4684ddb6SLionel Sambucmin(const _Tp& __a, const _Tp& __b) 2545*4684ddb6SLionel Sambuc{ 2546*4684ddb6SLionel Sambuc return _VSTD::min(__a, __b, __less<_Tp>()); 2547*4684ddb6SLionel Sambuc} 2548*4684ddb6SLionel Sambuc 2549*4684ddb6SLionel Sambuc#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2550*4684ddb6SLionel Sambuc 2551*4684ddb6SLionel Sambuctemplate<class _Tp, class _Compare> 2552*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2553*4684ddb6SLionel Sambuc_Tp 2554*4684ddb6SLionel Sambucmin(initializer_list<_Tp> __t, _Compare __comp) 2555*4684ddb6SLionel Sambuc{ 2556*4684ddb6SLionel Sambuc return *_VSTD::min_element(__t.begin(), __t.end(), __comp); 2557*4684ddb6SLionel Sambuc} 2558*4684ddb6SLionel Sambuc 2559*4684ddb6SLionel Sambuctemplate<class _Tp> 2560*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2561*4684ddb6SLionel Sambuc_Tp 2562*4684ddb6SLionel Sambucmin(initializer_list<_Tp> __t) 2563*4684ddb6SLionel Sambuc{ 2564*4684ddb6SLionel Sambuc return *_VSTD::min_element(__t.begin(), __t.end()); 2565*4684ddb6SLionel Sambuc} 2566*4684ddb6SLionel Sambuc 2567*4684ddb6SLionel Sambuc#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2568*4684ddb6SLionel Sambuc 2569*4684ddb6SLionel Sambuc// max_element 2570*4684ddb6SLionel Sambuc 2571*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Compare> 2572*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2573*4684ddb6SLionel Sambuc_ForwardIterator 2574*4684ddb6SLionel Sambucmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 2575*4684ddb6SLionel Sambuc{ 2576*4684ddb6SLionel Sambuc if (__first != __last) 2577*4684ddb6SLionel Sambuc { 2578*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2579*4684ddb6SLionel Sambuc while (++__i != __last) 2580*4684ddb6SLionel Sambuc if (__comp(*__first, *__i)) 2581*4684ddb6SLionel Sambuc __first = __i; 2582*4684ddb6SLionel Sambuc } 2583*4684ddb6SLionel Sambuc return __first; 2584*4684ddb6SLionel Sambuc} 2585*4684ddb6SLionel Sambuc 2586*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2587*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2588*4684ddb6SLionel Sambuc_ForwardIterator 2589*4684ddb6SLionel Sambucmax_element(_ForwardIterator __first, _ForwardIterator __last) 2590*4684ddb6SLionel Sambuc{ 2591*4684ddb6SLionel Sambuc return _VSTD::max_element(__first, __last, 2592*4684ddb6SLionel Sambuc __less<typename iterator_traits<_ForwardIterator>::value_type>()); 2593*4684ddb6SLionel Sambuc} 2594*4684ddb6SLionel Sambuc 2595*4684ddb6SLionel Sambuc// max 2596*4684ddb6SLionel Sambuc 2597*4684ddb6SLionel Sambuctemplate <class _Tp, class _Compare> 2598*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2599*4684ddb6SLionel Sambucconst _Tp& 2600*4684ddb6SLionel Sambucmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 2601*4684ddb6SLionel Sambuc{ 2602*4684ddb6SLionel Sambuc return __comp(__a, __b) ? __b : __a; 2603*4684ddb6SLionel Sambuc} 2604*4684ddb6SLionel Sambuc 2605*4684ddb6SLionel Sambuctemplate <class _Tp> 2606*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2607*4684ddb6SLionel Sambucconst _Tp& 2608*4684ddb6SLionel Sambucmax(const _Tp& __a, const _Tp& __b) 2609*4684ddb6SLionel Sambuc{ 2610*4684ddb6SLionel Sambuc return _VSTD::max(__a, __b, __less<_Tp>()); 2611*4684ddb6SLionel Sambuc} 2612*4684ddb6SLionel Sambuc 2613*4684ddb6SLionel Sambuc#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2614*4684ddb6SLionel Sambuc 2615*4684ddb6SLionel Sambuctemplate<class _Tp, class _Compare> 2616*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2617*4684ddb6SLionel Sambuc_Tp 2618*4684ddb6SLionel Sambucmax(initializer_list<_Tp> __t, _Compare __comp) 2619*4684ddb6SLionel Sambuc{ 2620*4684ddb6SLionel Sambuc return *_VSTD::max_element(__t.begin(), __t.end(), __comp); 2621*4684ddb6SLionel Sambuc} 2622*4684ddb6SLionel Sambuc 2623*4684ddb6SLionel Sambuctemplate<class _Tp> 2624*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2625*4684ddb6SLionel Sambuc_Tp 2626*4684ddb6SLionel Sambucmax(initializer_list<_Tp> __t) 2627*4684ddb6SLionel Sambuc{ 2628*4684ddb6SLionel Sambuc return *_VSTD::max_element(__t.begin(), __t.end()); 2629*4684ddb6SLionel Sambuc} 2630*4684ddb6SLionel Sambuc 2631*4684ddb6SLionel Sambuc#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2632*4684ddb6SLionel Sambuc 2633*4684ddb6SLionel Sambuc// minmax_element 2634*4684ddb6SLionel Sambuc 2635*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Compare> 2636*4684ddb6SLionel Sambucstd::pair<_ForwardIterator, _ForwardIterator> 2637*4684ddb6SLionel Sambucminmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 2638*4684ddb6SLionel Sambuc{ 2639*4684ddb6SLionel Sambuc std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first); 2640*4684ddb6SLionel Sambuc if (__first != __last) 2641*4684ddb6SLionel Sambuc { 2642*4684ddb6SLionel Sambuc if (++__first != __last) 2643*4684ddb6SLionel Sambuc { 2644*4684ddb6SLionel Sambuc if (__comp(*__first, *__result.first)) 2645*4684ddb6SLionel Sambuc __result.first = __first; 2646*4684ddb6SLionel Sambuc else 2647*4684ddb6SLionel Sambuc __result.second = __first; 2648*4684ddb6SLionel Sambuc while (++__first != __last) 2649*4684ddb6SLionel Sambuc { 2650*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 2651*4684ddb6SLionel Sambuc if (++__first == __last) 2652*4684ddb6SLionel Sambuc { 2653*4684ddb6SLionel Sambuc if (__comp(*__i, *__result.first)) 2654*4684ddb6SLionel Sambuc __result.first = __i; 2655*4684ddb6SLionel Sambuc else if (!__comp(*__i, *__result.second)) 2656*4684ddb6SLionel Sambuc __result.second = __i; 2657*4684ddb6SLionel Sambuc break; 2658*4684ddb6SLionel Sambuc } 2659*4684ddb6SLionel Sambuc else 2660*4684ddb6SLionel Sambuc { 2661*4684ddb6SLionel Sambuc if (__comp(*__first, *__i)) 2662*4684ddb6SLionel Sambuc { 2663*4684ddb6SLionel Sambuc if (__comp(*__first, *__result.first)) 2664*4684ddb6SLionel Sambuc __result.first = __first; 2665*4684ddb6SLionel Sambuc if (!__comp(*__i, *__result.second)) 2666*4684ddb6SLionel Sambuc __result.second = __i; 2667*4684ddb6SLionel Sambuc } 2668*4684ddb6SLionel Sambuc else 2669*4684ddb6SLionel Sambuc { 2670*4684ddb6SLionel Sambuc if (__comp(*__i, *__result.first)) 2671*4684ddb6SLionel Sambuc __result.first = __i; 2672*4684ddb6SLionel Sambuc if (!__comp(*__first, *__result.second)) 2673*4684ddb6SLionel Sambuc __result.second = __first; 2674*4684ddb6SLionel Sambuc } 2675*4684ddb6SLionel Sambuc } 2676*4684ddb6SLionel Sambuc } 2677*4684ddb6SLionel Sambuc } 2678*4684ddb6SLionel Sambuc } 2679*4684ddb6SLionel Sambuc return __result; 2680*4684ddb6SLionel Sambuc} 2681*4684ddb6SLionel Sambuc 2682*4684ddb6SLionel Sambuctemplate <class _ForwardIterator> 2683*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2684*4684ddb6SLionel Sambucstd::pair<_ForwardIterator, _ForwardIterator> 2685*4684ddb6SLionel Sambucminmax_element(_ForwardIterator __first, _ForwardIterator __last) 2686*4684ddb6SLionel Sambuc{ 2687*4684ddb6SLionel Sambuc return _VSTD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 2688*4684ddb6SLionel Sambuc} 2689*4684ddb6SLionel Sambuc 2690*4684ddb6SLionel Sambuc// minmax 2691*4684ddb6SLionel Sambuc 2692*4684ddb6SLionel Sambuctemplate<class _Tp, class _Compare> 2693*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2694*4684ddb6SLionel Sambucpair<const _Tp&, const _Tp&> 2695*4684ddb6SLionel Sambucminmax(const _Tp& __a, const _Tp& __b, _Compare __comp) 2696*4684ddb6SLionel Sambuc{ 2697*4684ddb6SLionel Sambuc return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) : 2698*4684ddb6SLionel Sambuc pair<const _Tp&, const _Tp&>(__a, __b); 2699*4684ddb6SLionel Sambuc} 2700*4684ddb6SLionel Sambuc 2701*4684ddb6SLionel Sambuctemplate<class _Tp> 2702*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2703*4684ddb6SLionel Sambucpair<const _Tp&, const _Tp&> 2704*4684ddb6SLionel Sambucminmax(const _Tp& __a, const _Tp& __b) 2705*4684ddb6SLionel Sambuc{ 2706*4684ddb6SLionel Sambuc return _VSTD::minmax(__a, __b, __less<_Tp>()); 2707*4684ddb6SLionel Sambuc} 2708*4684ddb6SLionel Sambuc 2709*4684ddb6SLionel Sambuc#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2710*4684ddb6SLionel Sambuc 2711*4684ddb6SLionel Sambuctemplate<class _Tp> 2712*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2713*4684ddb6SLionel Sambucpair<_Tp, _Tp> 2714*4684ddb6SLionel Sambucminmax(initializer_list<_Tp> __t) 2715*4684ddb6SLionel Sambuc{ 2716*4684ddb6SLionel Sambuc pair<const _Tp*, const _Tp*> __p = 2717*4684ddb6SLionel Sambuc _VSTD::minmax_element(__t.begin(), __t.end()); 2718*4684ddb6SLionel Sambuc return pair<_Tp, _Tp>(*__p.first, *__p.second); 2719*4684ddb6SLionel Sambuc} 2720*4684ddb6SLionel Sambuc 2721*4684ddb6SLionel Sambuctemplate<class _Tp, class _Compare> 2722*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 2723*4684ddb6SLionel Sambucpair<_Tp, _Tp> 2724*4684ddb6SLionel Sambucminmax(initializer_list<_Tp> __t, _Compare __comp) 2725*4684ddb6SLionel Sambuc{ 2726*4684ddb6SLionel Sambuc pair<const _Tp*, const _Tp*> __p = 2727*4684ddb6SLionel Sambuc _VSTD::minmax_element(__t.begin(), __t.end(), __comp); 2728*4684ddb6SLionel Sambuc return pair<_Tp, _Tp>(*__p.first, *__p.second); 2729*4684ddb6SLionel Sambuc} 2730*4684ddb6SLionel Sambuc 2731*4684ddb6SLionel Sambuc#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2732*4684ddb6SLionel Sambuc 2733*4684ddb6SLionel Sambuc// random_shuffle 2734*4684ddb6SLionel Sambuc 2735*4684ddb6SLionel Sambuc// __independent_bits_engine 2736*4684ddb6SLionel Sambuc 2737*4684ddb6SLionel Sambuctemplate <unsigned long long _Xp, size_t _Rp> 2738*4684ddb6SLionel Sambucstruct __log2_imp 2739*4684ddb6SLionel Sambuc{ 2740*4684ddb6SLionel Sambuc static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp 2741*4684ddb6SLionel Sambuc : __log2_imp<_Xp, _Rp - 1>::value; 2742*4684ddb6SLionel Sambuc}; 2743*4684ddb6SLionel Sambuc 2744*4684ddb6SLionel Sambuctemplate <unsigned long long _Xp> 2745*4684ddb6SLionel Sambucstruct __log2_imp<_Xp, 0> 2746*4684ddb6SLionel Sambuc{ 2747*4684ddb6SLionel Sambuc static const size_t value = 0; 2748*4684ddb6SLionel Sambuc}; 2749*4684ddb6SLionel Sambuc 2750*4684ddb6SLionel Sambuctemplate <size_t _Rp> 2751*4684ddb6SLionel Sambucstruct __log2_imp<0, _Rp> 2752*4684ddb6SLionel Sambuc{ 2753*4684ddb6SLionel Sambuc static const size_t value = _Rp + 1; 2754*4684ddb6SLionel Sambuc}; 2755*4684ddb6SLionel Sambuc 2756*4684ddb6SLionel Sambuctemplate <class _UI, _UI _Xp> 2757*4684ddb6SLionel Sambucstruct __log2 2758*4684ddb6SLionel Sambuc{ 2759*4684ddb6SLionel Sambuc static const size_t value = __log2_imp<_Xp, 2760*4684ddb6SLionel Sambuc sizeof(_UI) * __CHAR_BIT__ - 1>::value; 2761*4684ddb6SLionel Sambuc}; 2762*4684ddb6SLionel Sambuc 2763*4684ddb6SLionel Sambuctemplate<class _Engine, class _UIntType> 2764*4684ddb6SLionel Sambucclass __independent_bits_engine 2765*4684ddb6SLionel Sambuc{ 2766*4684ddb6SLionel Sambucpublic: 2767*4684ddb6SLionel Sambuc // types 2768*4684ddb6SLionel Sambuc typedef _UIntType result_type; 2769*4684ddb6SLionel Sambuc 2770*4684ddb6SLionel Sambucprivate: 2771*4684ddb6SLionel Sambuc typedef typename _Engine::result_type _Engine_result_type; 2772*4684ddb6SLionel Sambuc typedef typename conditional 2773*4684ddb6SLionel Sambuc < 2774*4684ddb6SLionel Sambuc sizeof(_Engine_result_type) <= sizeof(result_type), 2775*4684ddb6SLionel Sambuc result_type, 2776*4684ddb6SLionel Sambuc _Engine_result_type 2777*4684ddb6SLionel Sambuc >::type _Working_result_type; 2778*4684ddb6SLionel Sambuc 2779*4684ddb6SLionel Sambuc _Engine& __e_; 2780*4684ddb6SLionel Sambuc size_t __w_; 2781*4684ddb6SLionel Sambuc size_t __w0_; 2782*4684ddb6SLionel Sambuc size_t __n_; 2783*4684ddb6SLionel Sambuc size_t __n0_; 2784*4684ddb6SLionel Sambuc _Working_result_type __y0_; 2785*4684ddb6SLionel Sambuc _Working_result_type __y1_; 2786*4684ddb6SLionel Sambuc _Engine_result_type __mask0_; 2787*4684ddb6SLionel Sambuc _Engine_result_type __mask1_; 2788*4684ddb6SLionel Sambuc 2789*4684ddb6SLionel Sambuc#ifdef _LIBCPP_HAS_NO_CONSTEXPR 2790*4684ddb6SLionel Sambuc static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min 2791*4684ddb6SLionel Sambuc + _Working_result_type(1); 2792*4684ddb6SLionel Sambuc#else 2793*4684ddb6SLionel Sambuc static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() 2794*4684ddb6SLionel Sambuc + _Working_result_type(1); 2795*4684ddb6SLionel Sambuc#endif 2796*4684ddb6SLionel Sambuc static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value; 2797*4684ddb6SLionel Sambuc static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits; 2798*4684ddb6SLionel Sambuc static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits; 2799*4684ddb6SLionel Sambuc 2800*4684ddb6SLionel Sambucpublic: 2801*4684ddb6SLionel Sambuc // constructors and seeding functions 2802*4684ddb6SLionel Sambuc __independent_bits_engine(_Engine& __e, size_t __w); 2803*4684ddb6SLionel Sambuc 2804*4684ddb6SLionel Sambuc // generating functions 2805*4684ddb6SLionel Sambuc result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());} 2806*4684ddb6SLionel Sambuc 2807*4684ddb6SLionel Sambucprivate: 2808*4684ddb6SLionel Sambuc result_type __eval(false_type); 2809*4684ddb6SLionel Sambuc result_type __eval(true_type); 2810*4684ddb6SLionel Sambuc}; 2811*4684ddb6SLionel Sambuc 2812*4684ddb6SLionel Sambuctemplate<class _Engine, class _UIntType> 2813*4684ddb6SLionel Sambuc__independent_bits_engine<_Engine, _UIntType> 2814*4684ddb6SLionel Sambuc ::__independent_bits_engine(_Engine& __e, size_t __w) 2815*4684ddb6SLionel Sambuc : __e_(__e), 2816*4684ddb6SLionel Sambuc __w_(__w) 2817*4684ddb6SLionel Sambuc{ 2818*4684ddb6SLionel Sambuc __n_ = __w_ / __m + (__w_ % __m != 0); 2819*4684ddb6SLionel Sambuc __w0_ = __w_ / __n_; 2820*4684ddb6SLionel Sambuc if (_Rp == 0) 2821*4684ddb6SLionel Sambuc __y0_ = _Rp; 2822*4684ddb6SLionel Sambuc else if (__w0_ < _WDt) 2823*4684ddb6SLionel Sambuc __y0_ = (_Rp >> __w0_) << __w0_; 2824*4684ddb6SLionel Sambuc else 2825*4684ddb6SLionel Sambuc __y0_ = 0; 2826*4684ddb6SLionel Sambuc if (_Rp - __y0_ > __y0_ / __n_) 2827*4684ddb6SLionel Sambuc { 2828*4684ddb6SLionel Sambuc ++__n_; 2829*4684ddb6SLionel Sambuc __w0_ = __w_ / __n_; 2830*4684ddb6SLionel Sambuc if (__w0_ < _WDt) 2831*4684ddb6SLionel Sambuc __y0_ = (_Rp >> __w0_) << __w0_; 2832*4684ddb6SLionel Sambuc else 2833*4684ddb6SLionel Sambuc __y0_ = 0; 2834*4684ddb6SLionel Sambuc } 2835*4684ddb6SLionel Sambuc __n0_ = __n_ - __w_ % __n_; 2836*4684ddb6SLionel Sambuc if (__w0_ < _WDt - 1) 2837*4684ddb6SLionel Sambuc __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1); 2838*4684ddb6SLionel Sambuc else 2839*4684ddb6SLionel Sambuc __y1_ = 0; 2840*4684ddb6SLionel Sambuc __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) : 2841*4684ddb6SLionel Sambuc _Engine_result_type(0); 2842*4684ddb6SLionel Sambuc __mask1_ = __w0_ < _EDt - 1 ? 2843*4684ddb6SLionel Sambuc _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) : 2844*4684ddb6SLionel Sambuc _Engine_result_type(~0); 2845*4684ddb6SLionel Sambuc} 2846*4684ddb6SLionel Sambuc 2847*4684ddb6SLionel Sambuctemplate<class _Engine, class _UIntType> 2848*4684ddb6SLionel Sambucinline 2849*4684ddb6SLionel Sambuc_UIntType 2850*4684ddb6SLionel Sambuc__independent_bits_engine<_Engine, _UIntType>::__eval(false_type) 2851*4684ddb6SLionel Sambuc{ 2852*4684ddb6SLionel Sambuc return static_cast<result_type>(__e_() & __mask0_); 2853*4684ddb6SLionel Sambuc} 2854*4684ddb6SLionel Sambuc 2855*4684ddb6SLionel Sambuctemplate<class _Engine, class _UIntType> 2856*4684ddb6SLionel Sambuc_UIntType 2857*4684ddb6SLionel Sambuc__independent_bits_engine<_Engine, _UIntType>::__eval(true_type) 2858*4684ddb6SLionel Sambuc{ 2859*4684ddb6SLionel Sambuc result_type _Sp = 0; 2860*4684ddb6SLionel Sambuc for (size_t __k = 0; __k < __n0_; ++__k) 2861*4684ddb6SLionel Sambuc { 2862*4684ddb6SLionel Sambuc _Engine_result_type __u; 2863*4684ddb6SLionel Sambuc do 2864*4684ddb6SLionel Sambuc { 2865*4684ddb6SLionel Sambuc __u = __e_() - _Engine::min(); 2866*4684ddb6SLionel Sambuc } while (__u >= __y0_); 2867*4684ddb6SLionel Sambuc if (__w0_ < _WDt) 2868*4684ddb6SLionel Sambuc _Sp <<= __w0_; 2869*4684ddb6SLionel Sambuc else 2870*4684ddb6SLionel Sambuc _Sp = 0; 2871*4684ddb6SLionel Sambuc _Sp += __u & __mask0_; 2872*4684ddb6SLionel Sambuc } 2873*4684ddb6SLionel Sambuc for (size_t __k = __n0_; __k < __n_; ++__k) 2874*4684ddb6SLionel Sambuc { 2875*4684ddb6SLionel Sambuc _Engine_result_type __u; 2876*4684ddb6SLionel Sambuc do 2877*4684ddb6SLionel Sambuc { 2878*4684ddb6SLionel Sambuc __u = __e_() - _Engine::min(); 2879*4684ddb6SLionel Sambuc } while (__u >= __y1_); 2880*4684ddb6SLionel Sambuc if (__w0_ < _WDt - 1) 2881*4684ddb6SLionel Sambuc _Sp <<= __w0_ + 1; 2882*4684ddb6SLionel Sambuc else 2883*4684ddb6SLionel Sambuc _Sp = 0; 2884*4684ddb6SLionel Sambuc _Sp += __u & __mask1_; 2885*4684ddb6SLionel Sambuc } 2886*4684ddb6SLionel Sambuc return _Sp; 2887*4684ddb6SLionel Sambuc} 2888*4684ddb6SLionel Sambuc 2889*4684ddb6SLionel Sambuc// uniform_int_distribution 2890*4684ddb6SLionel Sambuc 2891*4684ddb6SLionel Sambuctemplate<class _IntType = int> 2892*4684ddb6SLionel Sambucclass uniform_int_distribution 2893*4684ddb6SLionel Sambuc{ 2894*4684ddb6SLionel Sambucpublic: 2895*4684ddb6SLionel Sambuc // types 2896*4684ddb6SLionel Sambuc typedef _IntType result_type; 2897*4684ddb6SLionel Sambuc 2898*4684ddb6SLionel Sambuc class param_type 2899*4684ddb6SLionel Sambuc { 2900*4684ddb6SLionel Sambuc result_type __a_; 2901*4684ddb6SLionel Sambuc result_type __b_; 2902*4684ddb6SLionel Sambuc public: 2903*4684ddb6SLionel Sambuc typedef uniform_int_distribution distribution_type; 2904*4684ddb6SLionel Sambuc 2905*4684ddb6SLionel Sambuc explicit param_type(result_type __a = 0, 2906*4684ddb6SLionel Sambuc result_type __b = numeric_limits<result_type>::max()) 2907*4684ddb6SLionel Sambuc : __a_(__a), __b_(__b) {} 2908*4684ddb6SLionel Sambuc 2909*4684ddb6SLionel Sambuc result_type a() const {return __a_;} 2910*4684ddb6SLionel Sambuc result_type b() const {return __b_;} 2911*4684ddb6SLionel Sambuc 2912*4684ddb6SLionel Sambuc friend bool operator==(const param_type& __x, const param_type& __y) 2913*4684ddb6SLionel Sambuc {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;} 2914*4684ddb6SLionel Sambuc friend bool operator!=(const param_type& __x, const param_type& __y) 2915*4684ddb6SLionel Sambuc {return !(__x == __y);} 2916*4684ddb6SLionel Sambuc }; 2917*4684ddb6SLionel Sambuc 2918*4684ddb6SLionel Sambucprivate: 2919*4684ddb6SLionel Sambuc param_type __p_; 2920*4684ddb6SLionel Sambuc 2921*4684ddb6SLionel Sambucpublic: 2922*4684ddb6SLionel Sambuc // constructors and reset functions 2923*4684ddb6SLionel Sambuc explicit uniform_int_distribution(result_type __a = 0, 2924*4684ddb6SLionel Sambuc result_type __b = numeric_limits<result_type>::max()) 2925*4684ddb6SLionel Sambuc : __p_(param_type(__a, __b)) {} 2926*4684ddb6SLionel Sambuc explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {} 2927*4684ddb6SLionel Sambuc void reset() {} 2928*4684ddb6SLionel Sambuc 2929*4684ddb6SLionel Sambuc // generating functions 2930*4684ddb6SLionel Sambuc template<class _URNG> result_type operator()(_URNG& __g) 2931*4684ddb6SLionel Sambuc {return (*this)(__g, __p_);} 2932*4684ddb6SLionel Sambuc template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p); 2933*4684ddb6SLionel Sambuc 2934*4684ddb6SLionel Sambuc // property functions 2935*4684ddb6SLionel Sambuc result_type a() const {return __p_.a();} 2936*4684ddb6SLionel Sambuc result_type b() const {return __p_.b();} 2937*4684ddb6SLionel Sambuc 2938*4684ddb6SLionel Sambuc param_type param() const {return __p_;} 2939*4684ddb6SLionel Sambuc void param(const param_type& __p) {__p_ = __p;} 2940*4684ddb6SLionel Sambuc 2941*4684ddb6SLionel Sambuc result_type min() const {return a();} 2942*4684ddb6SLionel Sambuc result_type max() const {return b();} 2943*4684ddb6SLionel Sambuc 2944*4684ddb6SLionel Sambuc friend bool operator==(const uniform_int_distribution& __x, 2945*4684ddb6SLionel Sambuc const uniform_int_distribution& __y) 2946*4684ddb6SLionel Sambuc {return __x.__p_ == __y.__p_;} 2947*4684ddb6SLionel Sambuc friend bool operator!=(const uniform_int_distribution& __x, 2948*4684ddb6SLionel Sambuc const uniform_int_distribution& __y) 2949*4684ddb6SLionel Sambuc {return !(__x == __y);} 2950*4684ddb6SLionel Sambuc}; 2951*4684ddb6SLionel Sambuc 2952*4684ddb6SLionel Sambuctemplate<class _IntType> 2953*4684ddb6SLionel Sambuctemplate<class _URNG> 2954*4684ddb6SLionel Sambuctypename uniform_int_distribution<_IntType>::result_type 2955*4684ddb6SLionel Sambucuniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) 2956*4684ddb6SLionel Sambuc{ 2957*4684ddb6SLionel Sambuc typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t), 2958*4684ddb6SLionel Sambuc uint32_t, uint64_t>::type _UIntType; 2959*4684ddb6SLionel Sambuc const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1); 2960*4684ddb6SLionel Sambuc if (_Rp == 1) 2961*4684ddb6SLionel Sambuc return __p.a(); 2962*4684ddb6SLionel Sambuc const size_t _Dt = numeric_limits<_UIntType>::digits; 2963*4684ddb6SLionel Sambuc typedef __independent_bits_engine<_URNG, _UIntType> _Eng; 2964*4684ddb6SLionel Sambuc if (_Rp == 0) 2965*4684ddb6SLionel Sambuc return static_cast<result_type>(_Eng(__g, _Dt)()); 2966*4684ddb6SLionel Sambuc size_t __w = _Dt - __clz(_Rp) - 1; 2967*4684ddb6SLionel Sambuc if ((_Rp & (_UIntType(~0) >> (_Dt - __w))) != 0) 2968*4684ddb6SLionel Sambuc ++__w; 2969*4684ddb6SLionel Sambuc _Eng __e(__g, __w); 2970*4684ddb6SLionel Sambuc _UIntType __u; 2971*4684ddb6SLionel Sambuc do 2972*4684ddb6SLionel Sambuc { 2973*4684ddb6SLionel Sambuc __u = __e(); 2974*4684ddb6SLionel Sambuc } while (__u >= _Rp); 2975*4684ddb6SLionel Sambuc return static_cast<result_type>(__u + __p.a()); 2976*4684ddb6SLionel Sambuc} 2977*4684ddb6SLionel Sambuc 2978*4684ddb6SLionel Sambucclass _LIBCPP_TYPE_VIS __rs_default; 2979*4684ddb6SLionel Sambuc 2980*4684ddb6SLionel Sambuc_LIBCPP_FUNC_VIS __rs_default __rs_get(); 2981*4684ddb6SLionel Sambuc 2982*4684ddb6SLionel Sambucclass _LIBCPP_TYPE_VIS __rs_default 2983*4684ddb6SLionel Sambuc{ 2984*4684ddb6SLionel Sambuc static unsigned __c_; 2985*4684ddb6SLionel Sambuc 2986*4684ddb6SLionel Sambuc __rs_default(); 2987*4684ddb6SLionel Sambucpublic: 2988*4684ddb6SLionel Sambuc typedef uint_fast32_t result_type; 2989*4684ddb6SLionel Sambuc 2990*4684ddb6SLionel Sambuc static const result_type _Min = 0; 2991*4684ddb6SLionel Sambuc static const result_type _Max = 0xFFFFFFFF; 2992*4684ddb6SLionel Sambuc 2993*4684ddb6SLionel Sambuc __rs_default(const __rs_default&); 2994*4684ddb6SLionel Sambuc ~__rs_default(); 2995*4684ddb6SLionel Sambuc 2996*4684ddb6SLionel Sambuc result_type operator()(); 2997*4684ddb6SLionel Sambuc 2998*4684ddb6SLionel Sambuc static _LIBCPP_CONSTEXPR result_type min() {return _Min;} 2999*4684ddb6SLionel Sambuc static _LIBCPP_CONSTEXPR result_type max() {return _Max;} 3000*4684ddb6SLionel Sambuc 3001*4684ddb6SLionel Sambuc friend _LIBCPP_FUNC_VIS __rs_default __rs_get(); 3002*4684ddb6SLionel Sambuc}; 3003*4684ddb6SLionel Sambuc 3004*4684ddb6SLionel Sambuc_LIBCPP_FUNC_VIS __rs_default __rs_get(); 3005*4684ddb6SLionel Sambuc 3006*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 3007*4684ddb6SLionel Sambucvoid 3008*4684ddb6SLionel Sambucrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) 3009*4684ddb6SLionel Sambuc{ 3010*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3011*4684ddb6SLionel Sambuc typedef uniform_int_distribution<ptrdiff_t> _Dp; 3012*4684ddb6SLionel Sambuc typedef typename _Dp::param_type _Pp; 3013*4684ddb6SLionel Sambuc difference_type __d = __last - __first; 3014*4684ddb6SLionel Sambuc if (__d > 1) 3015*4684ddb6SLionel Sambuc { 3016*4684ddb6SLionel Sambuc _Dp __uid; 3017*4684ddb6SLionel Sambuc __rs_default __g = __rs_get(); 3018*4684ddb6SLionel Sambuc for (--__last, --__d; __first < __last; ++__first, --__d) 3019*4684ddb6SLionel Sambuc { 3020*4684ddb6SLionel Sambuc difference_type __i = __uid(__g, _Pp(0, __d)); 3021*4684ddb6SLionel Sambuc if (__i != difference_type(0)) 3022*4684ddb6SLionel Sambuc swap(*__first, *(__first + __i)); 3023*4684ddb6SLionel Sambuc } 3024*4684ddb6SLionel Sambuc } 3025*4684ddb6SLionel Sambuc} 3026*4684ddb6SLionel Sambuc 3027*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _RandomNumberGenerator> 3028*4684ddb6SLionel Sambucvoid 3029*4684ddb6SLionel Sambucrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 3030*4684ddb6SLionel Sambuc#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3031*4684ddb6SLionel Sambuc _RandomNumberGenerator&& __rand) 3032*4684ddb6SLionel Sambuc#else 3033*4684ddb6SLionel Sambuc _RandomNumberGenerator& __rand) 3034*4684ddb6SLionel Sambuc#endif 3035*4684ddb6SLionel Sambuc{ 3036*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3037*4684ddb6SLionel Sambuc difference_type __d = __last - __first; 3038*4684ddb6SLionel Sambuc if (__d > 1) 3039*4684ddb6SLionel Sambuc { 3040*4684ddb6SLionel Sambuc for (--__last; __first < __last; ++__first, --__d) 3041*4684ddb6SLionel Sambuc { 3042*4684ddb6SLionel Sambuc difference_type __i = __rand(__d); 3043*4684ddb6SLionel Sambuc swap(*__first, *(__first + __i)); 3044*4684ddb6SLionel Sambuc } 3045*4684ddb6SLionel Sambuc } 3046*4684ddb6SLionel Sambuc} 3047*4684ddb6SLionel Sambuc 3048*4684ddb6SLionel Sambuctemplate<class _RandomAccessIterator, class _UniformRandomNumberGenerator> 3049*4684ddb6SLionel Sambuc void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, 3050*4684ddb6SLionel Sambuc#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3051*4684ddb6SLionel Sambuc _UniformRandomNumberGenerator&& __g) 3052*4684ddb6SLionel Sambuc#else 3053*4684ddb6SLionel Sambuc _UniformRandomNumberGenerator& __g) 3054*4684ddb6SLionel Sambuc#endif 3055*4684ddb6SLionel Sambuc{ 3056*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3057*4684ddb6SLionel Sambuc typedef uniform_int_distribution<ptrdiff_t> _Dp; 3058*4684ddb6SLionel Sambuc typedef typename _Dp::param_type _Pp; 3059*4684ddb6SLionel Sambuc difference_type __d = __last - __first; 3060*4684ddb6SLionel Sambuc if (__d > 1) 3061*4684ddb6SLionel Sambuc { 3062*4684ddb6SLionel Sambuc _Dp __uid; 3063*4684ddb6SLionel Sambuc for (--__last, --__d; __first < __last; ++__first, --__d) 3064*4684ddb6SLionel Sambuc { 3065*4684ddb6SLionel Sambuc difference_type __i = __uid(__g, _Pp(0, __d)); 3066*4684ddb6SLionel Sambuc if (__i != difference_type(0)) 3067*4684ddb6SLionel Sambuc swap(*__first, *(__first + __i)); 3068*4684ddb6SLionel Sambuc } 3069*4684ddb6SLionel Sambuc } 3070*4684ddb6SLionel Sambuc} 3071*4684ddb6SLionel Sambuc 3072*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _Predicate> 3073*4684ddb6SLionel Sambucbool 3074*4684ddb6SLionel Sambucis_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) 3075*4684ddb6SLionel Sambuc{ 3076*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 3077*4684ddb6SLionel Sambuc if (!__pred(*__first)) 3078*4684ddb6SLionel Sambuc break; 3079*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 3080*4684ddb6SLionel Sambuc if (__pred(*__first)) 3081*4684ddb6SLionel Sambuc return false; 3082*4684ddb6SLionel Sambuc return true; 3083*4684ddb6SLionel Sambuc} 3084*4684ddb6SLionel Sambuc 3085*4684ddb6SLionel Sambuc// partition 3086*4684ddb6SLionel Sambuc 3087*4684ddb6SLionel Sambuctemplate <class _Predicate, class _ForwardIterator> 3088*4684ddb6SLionel Sambuc_ForwardIterator 3089*4684ddb6SLionel Sambuc__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) 3090*4684ddb6SLionel Sambuc{ 3091*4684ddb6SLionel Sambuc while (true) 3092*4684ddb6SLionel Sambuc { 3093*4684ddb6SLionel Sambuc if (__first == __last) 3094*4684ddb6SLionel Sambuc return __first; 3095*4684ddb6SLionel Sambuc if (!__pred(*__first)) 3096*4684ddb6SLionel Sambuc break; 3097*4684ddb6SLionel Sambuc ++__first; 3098*4684ddb6SLionel Sambuc } 3099*4684ddb6SLionel Sambuc for (_ForwardIterator __p = __first; ++__p != __last;) 3100*4684ddb6SLionel Sambuc { 3101*4684ddb6SLionel Sambuc if (__pred(*__p)) 3102*4684ddb6SLionel Sambuc { 3103*4684ddb6SLionel Sambuc swap(*__first, *__p); 3104*4684ddb6SLionel Sambuc ++__first; 3105*4684ddb6SLionel Sambuc } 3106*4684ddb6SLionel Sambuc } 3107*4684ddb6SLionel Sambuc return __first; 3108*4684ddb6SLionel Sambuc} 3109*4684ddb6SLionel Sambuc 3110*4684ddb6SLionel Sambuctemplate <class _Predicate, class _BidirectionalIterator> 3111*4684ddb6SLionel Sambuc_BidirectionalIterator 3112*4684ddb6SLionel Sambuc__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 3113*4684ddb6SLionel Sambuc bidirectional_iterator_tag) 3114*4684ddb6SLionel Sambuc{ 3115*4684ddb6SLionel Sambuc while (true) 3116*4684ddb6SLionel Sambuc { 3117*4684ddb6SLionel Sambuc while (true) 3118*4684ddb6SLionel Sambuc { 3119*4684ddb6SLionel Sambuc if (__first == __last) 3120*4684ddb6SLionel Sambuc return __first; 3121*4684ddb6SLionel Sambuc if (!__pred(*__first)) 3122*4684ddb6SLionel Sambuc break; 3123*4684ddb6SLionel Sambuc ++__first; 3124*4684ddb6SLionel Sambuc } 3125*4684ddb6SLionel Sambuc do 3126*4684ddb6SLionel Sambuc { 3127*4684ddb6SLionel Sambuc if (__first == --__last) 3128*4684ddb6SLionel Sambuc return __first; 3129*4684ddb6SLionel Sambuc } while (!__pred(*__last)); 3130*4684ddb6SLionel Sambuc swap(*__first, *__last); 3131*4684ddb6SLionel Sambuc ++__first; 3132*4684ddb6SLionel Sambuc } 3133*4684ddb6SLionel Sambuc} 3134*4684ddb6SLionel Sambuc 3135*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Predicate> 3136*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3137*4684ddb6SLionel Sambuc_ForwardIterator 3138*4684ddb6SLionel Sambucpartition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 3139*4684ddb6SLionel Sambuc{ 3140*4684ddb6SLionel Sambuc return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type> 3141*4684ddb6SLionel Sambuc (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 3142*4684ddb6SLionel Sambuc} 3143*4684ddb6SLionel Sambuc 3144*4684ddb6SLionel Sambuc// partition_copy 3145*4684ddb6SLionel Sambuc 3146*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _OutputIterator1, 3147*4684ddb6SLionel Sambuc class _OutputIterator2, class _Predicate> 3148*4684ddb6SLionel Sambucpair<_OutputIterator1, _OutputIterator2> 3149*4684ddb6SLionel Sambucpartition_copy(_InputIterator __first, _InputIterator __last, 3150*4684ddb6SLionel Sambuc _OutputIterator1 __out_true, _OutputIterator2 __out_false, 3151*4684ddb6SLionel Sambuc _Predicate __pred) 3152*4684ddb6SLionel Sambuc{ 3153*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 3154*4684ddb6SLionel Sambuc { 3155*4684ddb6SLionel Sambuc if (__pred(*__first)) 3156*4684ddb6SLionel Sambuc { 3157*4684ddb6SLionel Sambuc *__out_true = *__first; 3158*4684ddb6SLionel Sambuc ++__out_true; 3159*4684ddb6SLionel Sambuc } 3160*4684ddb6SLionel Sambuc else 3161*4684ddb6SLionel Sambuc { 3162*4684ddb6SLionel Sambuc *__out_false = *__first; 3163*4684ddb6SLionel Sambuc ++__out_false; 3164*4684ddb6SLionel Sambuc } 3165*4684ddb6SLionel Sambuc } 3166*4684ddb6SLionel Sambuc return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); 3167*4684ddb6SLionel Sambuc} 3168*4684ddb6SLionel Sambuc 3169*4684ddb6SLionel Sambuc// partition_point 3170*4684ddb6SLionel Sambuc 3171*4684ddb6SLionel Sambuctemplate<class _ForwardIterator, class _Predicate> 3172*4684ddb6SLionel Sambuc_ForwardIterator 3173*4684ddb6SLionel Sambucpartition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 3174*4684ddb6SLionel Sambuc{ 3175*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 3176*4684ddb6SLionel Sambuc difference_type __len = _VSTD::distance(__first, __last); 3177*4684ddb6SLionel Sambuc while (__len != 0) 3178*4684ddb6SLionel Sambuc { 3179*4684ddb6SLionel Sambuc difference_type __l2 = __len / 2; 3180*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 3181*4684ddb6SLionel Sambuc _VSTD::advance(__m, __l2); 3182*4684ddb6SLionel Sambuc if (__pred(*__m)) 3183*4684ddb6SLionel Sambuc { 3184*4684ddb6SLionel Sambuc __first = ++__m; 3185*4684ddb6SLionel Sambuc __len -= __l2 + 1; 3186*4684ddb6SLionel Sambuc } 3187*4684ddb6SLionel Sambuc else 3188*4684ddb6SLionel Sambuc __len = __l2; 3189*4684ddb6SLionel Sambuc } 3190*4684ddb6SLionel Sambuc return __first; 3191*4684ddb6SLionel Sambuc} 3192*4684ddb6SLionel Sambuc 3193*4684ddb6SLionel Sambuc// stable_partition 3194*4684ddb6SLionel Sambuc 3195*4684ddb6SLionel Sambuctemplate <class _Predicate, class _ForwardIterator, class _Distance, class _Pair> 3196*4684ddb6SLionel Sambuc_ForwardIterator 3197*4684ddb6SLionel Sambuc__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 3198*4684ddb6SLionel Sambuc _Distance __len, _Pair __p, forward_iterator_tag __fit) 3199*4684ddb6SLionel Sambuc{ 3200*4684ddb6SLionel Sambuc // *__first is known to be false 3201*4684ddb6SLionel Sambuc // __len >= 1 3202*4684ddb6SLionel Sambuc if (__len == 1) 3203*4684ddb6SLionel Sambuc return __first; 3204*4684ddb6SLionel Sambuc if (__len == 2) 3205*4684ddb6SLionel Sambuc { 3206*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 3207*4684ddb6SLionel Sambuc if (__pred(*++__m)) 3208*4684ddb6SLionel Sambuc { 3209*4684ddb6SLionel Sambuc swap(*__first, *__m); 3210*4684ddb6SLionel Sambuc return __m; 3211*4684ddb6SLionel Sambuc } 3212*4684ddb6SLionel Sambuc return __first; 3213*4684ddb6SLionel Sambuc } 3214*4684ddb6SLionel Sambuc if (__len <= __p.second) 3215*4684ddb6SLionel Sambuc { // The buffer is big enough to use 3216*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3217*4684ddb6SLionel Sambuc __destruct_n __d(0); 3218*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 3219*4684ddb6SLionel Sambuc // Move the falses into the temporary buffer, and the trues to the front of the line 3220*4684ddb6SLionel Sambuc // Update __first to always point to the end of the trues 3221*4684ddb6SLionel Sambuc value_type* __t = __p.first; 3222*4684ddb6SLionel Sambuc ::new(__t) value_type(_VSTD::move(*__first)); 3223*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3224*4684ddb6SLionel Sambuc ++__t; 3225*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 3226*4684ddb6SLionel Sambuc while (++__i != __last) 3227*4684ddb6SLionel Sambuc { 3228*4684ddb6SLionel Sambuc if (__pred(*__i)) 3229*4684ddb6SLionel Sambuc { 3230*4684ddb6SLionel Sambuc *__first = _VSTD::move(*__i); 3231*4684ddb6SLionel Sambuc ++__first; 3232*4684ddb6SLionel Sambuc } 3233*4684ddb6SLionel Sambuc else 3234*4684ddb6SLionel Sambuc { 3235*4684ddb6SLionel Sambuc ::new(__t) value_type(_VSTD::move(*__i)); 3236*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3237*4684ddb6SLionel Sambuc ++__t; 3238*4684ddb6SLionel Sambuc } 3239*4684ddb6SLionel Sambuc } 3240*4684ddb6SLionel Sambuc // All trues now at start of range, all falses in buffer 3241*4684ddb6SLionel Sambuc // Move falses back into range, but don't mess up __first which points to first false 3242*4684ddb6SLionel Sambuc __i = __first; 3243*4684ddb6SLionel Sambuc for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 3244*4684ddb6SLionel Sambuc *__i = _VSTD::move(*__t2); 3245*4684ddb6SLionel Sambuc // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 3246*4684ddb6SLionel Sambuc return __first; 3247*4684ddb6SLionel Sambuc } 3248*4684ddb6SLionel Sambuc // Else not enough buffer, do in place 3249*4684ddb6SLionel Sambuc // __len >= 3 3250*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 3251*4684ddb6SLionel Sambuc _Distance __len2 = __len / 2; // __len2 >= 2 3252*4684ddb6SLionel Sambuc _VSTD::advance(__m, __len2); 3253*4684ddb6SLionel Sambuc // recurse on [__first, __m), *__first know to be false 3254*4684ddb6SLionel Sambuc // F????????????????? 3255*4684ddb6SLionel Sambuc // f m l 3256*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 3257*4684ddb6SLionel Sambuc _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit); 3258*4684ddb6SLionel Sambuc // TTTFFFFF?????????? 3259*4684ddb6SLionel Sambuc // f ff m l 3260*4684ddb6SLionel Sambuc // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 3261*4684ddb6SLionel Sambuc _ForwardIterator __m1 = __m; 3262*4684ddb6SLionel Sambuc _ForwardIterator __second_false = __last; 3263*4684ddb6SLionel Sambuc _Distance __len_half = __len - __len2; 3264*4684ddb6SLionel Sambuc while (__pred(*__m1)) 3265*4684ddb6SLionel Sambuc { 3266*4684ddb6SLionel Sambuc if (++__m1 == __last) 3267*4684ddb6SLionel Sambuc goto __second_half_done; 3268*4684ddb6SLionel Sambuc --__len_half; 3269*4684ddb6SLionel Sambuc } 3270*4684ddb6SLionel Sambuc // TTTFFFFFTTTF?????? 3271*4684ddb6SLionel Sambuc // f ff m m1 l 3272*4684ddb6SLionel Sambuc __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit); 3273*4684ddb6SLionel Sambuc__second_half_done: 3274*4684ddb6SLionel Sambuc // TTTFFFFFTTTTTFFFFF 3275*4684ddb6SLionel Sambuc // f ff m sf l 3276*4684ddb6SLionel Sambuc return _VSTD::rotate(__first_false, __m, __second_false); 3277*4684ddb6SLionel Sambuc // TTTTTTTTFFFFFFFFFF 3278*4684ddb6SLionel Sambuc // | 3279*4684ddb6SLionel Sambuc} 3280*4684ddb6SLionel Sambuc 3281*4684ddb6SLionel Sambucstruct __return_temporary_buffer 3282*4684ddb6SLionel Sambuc{ 3283*4684ddb6SLionel Sambuc template <class _Tp> 3284*4684ddb6SLionel Sambuc _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);} 3285*4684ddb6SLionel Sambuc}; 3286*4684ddb6SLionel Sambuc 3287*4684ddb6SLionel Sambuctemplate <class _Predicate, class _ForwardIterator> 3288*4684ddb6SLionel Sambuc_ForwardIterator 3289*4684ddb6SLionel Sambuc__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, 3290*4684ddb6SLionel Sambuc forward_iterator_tag) 3291*4684ddb6SLionel Sambuc{ 3292*4684ddb6SLionel Sambuc const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment 3293*4684ddb6SLionel Sambuc // Either prove all true and return __first or point to first false 3294*4684ddb6SLionel Sambuc while (true) 3295*4684ddb6SLionel Sambuc { 3296*4684ddb6SLionel Sambuc if (__first == __last) 3297*4684ddb6SLionel Sambuc return __first; 3298*4684ddb6SLionel Sambuc if (!__pred(*__first)) 3299*4684ddb6SLionel Sambuc break; 3300*4684ddb6SLionel Sambuc ++__first; 3301*4684ddb6SLionel Sambuc } 3302*4684ddb6SLionel Sambuc // We now have a reduced range [__first, __last) 3303*4684ddb6SLionel Sambuc // *__first is known to be false 3304*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 3305*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3306*4684ddb6SLionel Sambuc difference_type __len = _VSTD::distance(__first, __last); 3307*4684ddb6SLionel Sambuc pair<value_type*, ptrdiff_t> __p(0, 0); 3308*4684ddb6SLionel Sambuc unique_ptr<value_type, __return_temporary_buffer> __h; 3309*4684ddb6SLionel Sambuc if (__len >= __alloc_limit) 3310*4684ddb6SLionel Sambuc { 3311*4684ddb6SLionel Sambuc __p = _VSTD::get_temporary_buffer<value_type>(__len); 3312*4684ddb6SLionel Sambuc __h.reset(__p.first); 3313*4684ddb6SLionel Sambuc } 3314*4684ddb6SLionel Sambuc return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 3315*4684ddb6SLionel Sambuc (__first, __last, __pred, __len, __p, forward_iterator_tag()); 3316*4684ddb6SLionel Sambuc} 3317*4684ddb6SLionel Sambuc 3318*4684ddb6SLionel Sambuctemplate <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair> 3319*4684ddb6SLionel Sambuc_BidirectionalIterator 3320*4684ddb6SLionel Sambuc__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 3321*4684ddb6SLionel Sambuc _Distance __len, _Pair __p, bidirectional_iterator_tag __bit) 3322*4684ddb6SLionel Sambuc{ 3323*4684ddb6SLionel Sambuc // *__first is known to be false 3324*4684ddb6SLionel Sambuc // *__last is known to be true 3325*4684ddb6SLionel Sambuc // __len >= 2 3326*4684ddb6SLionel Sambuc if (__len == 2) 3327*4684ddb6SLionel Sambuc { 3328*4684ddb6SLionel Sambuc swap(*__first, *__last); 3329*4684ddb6SLionel Sambuc return __last; 3330*4684ddb6SLionel Sambuc } 3331*4684ddb6SLionel Sambuc if (__len == 3) 3332*4684ddb6SLionel Sambuc { 3333*4684ddb6SLionel Sambuc _BidirectionalIterator __m = __first; 3334*4684ddb6SLionel Sambuc if (__pred(*++__m)) 3335*4684ddb6SLionel Sambuc { 3336*4684ddb6SLionel Sambuc swap(*__first, *__m); 3337*4684ddb6SLionel Sambuc swap(*__m, *__last); 3338*4684ddb6SLionel Sambuc return __last; 3339*4684ddb6SLionel Sambuc } 3340*4684ddb6SLionel Sambuc swap(*__m, *__last); 3341*4684ddb6SLionel Sambuc swap(*__first, *__m); 3342*4684ddb6SLionel Sambuc return __m; 3343*4684ddb6SLionel Sambuc } 3344*4684ddb6SLionel Sambuc if (__len <= __p.second) 3345*4684ddb6SLionel Sambuc { // The buffer is big enough to use 3346*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 3347*4684ddb6SLionel Sambuc __destruct_n __d(0); 3348*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h(__p.first, __d); 3349*4684ddb6SLionel Sambuc // Move the falses into the temporary buffer, and the trues to the front of the line 3350*4684ddb6SLionel Sambuc // Update __first to always point to the end of the trues 3351*4684ddb6SLionel Sambuc value_type* __t = __p.first; 3352*4684ddb6SLionel Sambuc ::new(__t) value_type(_VSTD::move(*__first)); 3353*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3354*4684ddb6SLionel Sambuc ++__t; 3355*4684ddb6SLionel Sambuc _BidirectionalIterator __i = __first; 3356*4684ddb6SLionel Sambuc while (++__i != __last) 3357*4684ddb6SLionel Sambuc { 3358*4684ddb6SLionel Sambuc if (__pred(*__i)) 3359*4684ddb6SLionel Sambuc { 3360*4684ddb6SLionel Sambuc *__first = _VSTD::move(*__i); 3361*4684ddb6SLionel Sambuc ++__first; 3362*4684ddb6SLionel Sambuc } 3363*4684ddb6SLionel Sambuc else 3364*4684ddb6SLionel Sambuc { 3365*4684ddb6SLionel Sambuc ::new(__t) value_type(_VSTD::move(*__i)); 3366*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3367*4684ddb6SLionel Sambuc ++__t; 3368*4684ddb6SLionel Sambuc } 3369*4684ddb6SLionel Sambuc } 3370*4684ddb6SLionel Sambuc // move *__last, known to be true 3371*4684ddb6SLionel Sambuc *__first = _VSTD::move(*__i); 3372*4684ddb6SLionel Sambuc __i = ++__first; 3373*4684ddb6SLionel Sambuc // All trues now at start of range, all falses in buffer 3374*4684ddb6SLionel Sambuc // Move falses back into range, but don't mess up __first which points to first false 3375*4684ddb6SLionel Sambuc for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) 3376*4684ddb6SLionel Sambuc *__i = _VSTD::move(*__t2); 3377*4684ddb6SLionel Sambuc // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer 3378*4684ddb6SLionel Sambuc return __first; 3379*4684ddb6SLionel Sambuc } 3380*4684ddb6SLionel Sambuc // Else not enough buffer, do in place 3381*4684ddb6SLionel Sambuc // __len >= 4 3382*4684ddb6SLionel Sambuc _BidirectionalIterator __m = __first; 3383*4684ddb6SLionel Sambuc _Distance __len2 = __len / 2; // __len2 >= 2 3384*4684ddb6SLionel Sambuc _VSTD::advance(__m, __len2); 3385*4684ddb6SLionel Sambuc // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false 3386*4684ddb6SLionel Sambuc // F????????????????T 3387*4684ddb6SLionel Sambuc // f m l 3388*4684ddb6SLionel Sambuc _BidirectionalIterator __m1 = __m; 3389*4684ddb6SLionel Sambuc _BidirectionalIterator __first_false = __first; 3390*4684ddb6SLionel Sambuc _Distance __len_half = __len2; 3391*4684ddb6SLionel Sambuc while (!__pred(*--__m1)) 3392*4684ddb6SLionel Sambuc { 3393*4684ddb6SLionel Sambuc if (__m1 == __first) 3394*4684ddb6SLionel Sambuc goto __first_half_done; 3395*4684ddb6SLionel Sambuc --__len_half; 3396*4684ddb6SLionel Sambuc } 3397*4684ddb6SLionel Sambuc // F???TFFF?????????T 3398*4684ddb6SLionel Sambuc // f m1 m l 3399*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Predicate>::type _PredRef; 3400*4684ddb6SLionel Sambuc __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit); 3401*4684ddb6SLionel Sambuc__first_half_done: 3402*4684ddb6SLionel Sambuc // TTTFFFFF?????????T 3403*4684ddb6SLionel Sambuc // f ff m l 3404*4684ddb6SLionel Sambuc // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true 3405*4684ddb6SLionel Sambuc __m1 = __m; 3406*4684ddb6SLionel Sambuc _BidirectionalIterator __second_false = __last; 3407*4684ddb6SLionel Sambuc ++__second_false; 3408*4684ddb6SLionel Sambuc __len_half = __len - __len2; 3409*4684ddb6SLionel Sambuc while (__pred(*__m1)) 3410*4684ddb6SLionel Sambuc { 3411*4684ddb6SLionel Sambuc if (++__m1 == __last) 3412*4684ddb6SLionel Sambuc goto __second_half_done; 3413*4684ddb6SLionel Sambuc --__len_half; 3414*4684ddb6SLionel Sambuc } 3415*4684ddb6SLionel Sambuc // TTTFFFFFTTTF?????T 3416*4684ddb6SLionel Sambuc // f ff m m1 l 3417*4684ddb6SLionel Sambuc __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit); 3418*4684ddb6SLionel Sambuc__second_half_done: 3419*4684ddb6SLionel Sambuc // TTTFFFFFTTTTTFFFFF 3420*4684ddb6SLionel Sambuc // f ff m sf l 3421*4684ddb6SLionel Sambuc return _VSTD::rotate(__first_false, __m, __second_false); 3422*4684ddb6SLionel Sambuc // TTTTTTTTFFFFFFFFFF 3423*4684ddb6SLionel Sambuc // | 3424*4684ddb6SLionel Sambuc} 3425*4684ddb6SLionel Sambuc 3426*4684ddb6SLionel Sambuctemplate <class _Predicate, class _BidirectionalIterator> 3427*4684ddb6SLionel Sambuc_BidirectionalIterator 3428*4684ddb6SLionel Sambuc__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, 3429*4684ddb6SLionel Sambuc bidirectional_iterator_tag) 3430*4684ddb6SLionel Sambuc{ 3431*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 3432*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 3433*4684ddb6SLionel Sambuc const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment 3434*4684ddb6SLionel Sambuc // Either prove all true and return __first or point to first false 3435*4684ddb6SLionel Sambuc while (true) 3436*4684ddb6SLionel Sambuc { 3437*4684ddb6SLionel Sambuc if (__first == __last) 3438*4684ddb6SLionel Sambuc return __first; 3439*4684ddb6SLionel Sambuc if (!__pred(*__first)) 3440*4684ddb6SLionel Sambuc break; 3441*4684ddb6SLionel Sambuc ++__first; 3442*4684ddb6SLionel Sambuc } 3443*4684ddb6SLionel Sambuc // __first points to first false, everything prior to __first is already set. 3444*4684ddb6SLionel Sambuc // Either prove [__first, __last) is all false and return __first, or point __last to last true 3445*4684ddb6SLionel Sambuc do 3446*4684ddb6SLionel Sambuc { 3447*4684ddb6SLionel Sambuc if (__first == --__last) 3448*4684ddb6SLionel Sambuc return __first; 3449*4684ddb6SLionel Sambuc } while (!__pred(*__last)); 3450*4684ddb6SLionel Sambuc // We now have a reduced range [__first, __last] 3451*4684ddb6SLionel Sambuc // *__first is known to be false 3452*4684ddb6SLionel Sambuc // *__last is known to be true 3453*4684ddb6SLionel Sambuc // __len >= 2 3454*4684ddb6SLionel Sambuc difference_type __len = _VSTD::distance(__first, __last) + 1; 3455*4684ddb6SLionel Sambuc pair<value_type*, ptrdiff_t> __p(0, 0); 3456*4684ddb6SLionel Sambuc unique_ptr<value_type, __return_temporary_buffer> __h; 3457*4684ddb6SLionel Sambuc if (__len >= __alloc_limit) 3458*4684ddb6SLionel Sambuc { 3459*4684ddb6SLionel Sambuc __p = _VSTD::get_temporary_buffer<value_type>(__len); 3460*4684ddb6SLionel Sambuc __h.reset(__p.first); 3461*4684ddb6SLionel Sambuc } 3462*4684ddb6SLionel Sambuc return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 3463*4684ddb6SLionel Sambuc (__first, __last, __pred, __len, __p, bidirectional_iterator_tag()); 3464*4684ddb6SLionel Sambuc} 3465*4684ddb6SLionel Sambuc 3466*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Predicate> 3467*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3468*4684ddb6SLionel Sambuc_ForwardIterator 3469*4684ddb6SLionel Sambucstable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) 3470*4684ddb6SLionel Sambuc{ 3471*4684ddb6SLionel Sambuc return __stable_partition<typename add_lvalue_reference<_Predicate>::type> 3472*4684ddb6SLionel Sambuc (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); 3473*4684ddb6SLionel Sambuc} 3474*4684ddb6SLionel Sambuc 3475*4684ddb6SLionel Sambuc// is_sorted_until 3476*4684ddb6SLionel Sambuc 3477*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Compare> 3478*4684ddb6SLionel Sambuc_ForwardIterator 3479*4684ddb6SLionel Sambucis_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 3480*4684ddb6SLionel Sambuc{ 3481*4684ddb6SLionel Sambuc if (__first != __last) 3482*4684ddb6SLionel Sambuc { 3483*4684ddb6SLionel Sambuc _ForwardIterator __i = __first; 3484*4684ddb6SLionel Sambuc while (++__i != __last) 3485*4684ddb6SLionel Sambuc { 3486*4684ddb6SLionel Sambuc if (__comp(*__i, *__first)) 3487*4684ddb6SLionel Sambuc return __i; 3488*4684ddb6SLionel Sambuc __first = __i; 3489*4684ddb6SLionel Sambuc } 3490*4684ddb6SLionel Sambuc } 3491*4684ddb6SLionel Sambuc return __last; 3492*4684ddb6SLionel Sambuc} 3493*4684ddb6SLionel Sambuc 3494*4684ddb6SLionel Sambuctemplate<class _ForwardIterator> 3495*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3496*4684ddb6SLionel Sambuc_ForwardIterator 3497*4684ddb6SLionel Sambucis_sorted_until(_ForwardIterator __first, _ForwardIterator __last) 3498*4684ddb6SLionel Sambuc{ 3499*4684ddb6SLionel Sambuc return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 3500*4684ddb6SLionel Sambuc} 3501*4684ddb6SLionel Sambuc 3502*4684ddb6SLionel Sambuc// is_sorted 3503*4684ddb6SLionel Sambuc 3504*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Compare> 3505*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3506*4684ddb6SLionel Sambucbool 3507*4684ddb6SLionel Sambucis_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) 3508*4684ddb6SLionel Sambuc{ 3509*4684ddb6SLionel Sambuc return _VSTD::is_sorted_until(__first, __last, __comp) == __last; 3510*4684ddb6SLionel Sambuc} 3511*4684ddb6SLionel Sambuc 3512*4684ddb6SLionel Sambuctemplate<class _ForwardIterator> 3513*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3514*4684ddb6SLionel Sambucbool 3515*4684ddb6SLionel Sambucis_sorted(_ForwardIterator __first, _ForwardIterator __last) 3516*4684ddb6SLionel Sambuc{ 3517*4684ddb6SLionel Sambuc return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); 3518*4684ddb6SLionel Sambuc} 3519*4684ddb6SLionel Sambuc 3520*4684ddb6SLionel Sambuc// sort 3521*4684ddb6SLionel Sambuc 3522*4684ddb6SLionel Sambuc// stable, 2-3 compares, 0-2 swaps 3523*4684ddb6SLionel Sambuc 3524*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator> 3525*4684ddb6SLionel Sambucunsigned 3526*4684ddb6SLionel Sambuc__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c) 3527*4684ddb6SLionel Sambuc{ 3528*4684ddb6SLionel Sambuc unsigned __r = 0; 3529*4684ddb6SLionel Sambuc if (!__c(*__y, *__x)) // if x <= y 3530*4684ddb6SLionel Sambuc { 3531*4684ddb6SLionel Sambuc if (!__c(*__z, *__y)) // if y <= z 3532*4684ddb6SLionel Sambuc return __r; // x <= y && y <= z 3533*4684ddb6SLionel Sambuc // x <= y && y > z 3534*4684ddb6SLionel Sambuc swap(*__y, *__z); // x <= z && y < z 3535*4684ddb6SLionel Sambuc __r = 1; 3536*4684ddb6SLionel Sambuc if (__c(*__y, *__x)) // if x > y 3537*4684ddb6SLionel Sambuc { 3538*4684ddb6SLionel Sambuc swap(*__x, *__y); // x < y && y <= z 3539*4684ddb6SLionel Sambuc __r = 2; 3540*4684ddb6SLionel Sambuc } 3541*4684ddb6SLionel Sambuc return __r; // x <= y && y < z 3542*4684ddb6SLionel Sambuc } 3543*4684ddb6SLionel Sambuc if (__c(*__z, *__y)) // x > y, if y > z 3544*4684ddb6SLionel Sambuc { 3545*4684ddb6SLionel Sambuc swap(*__x, *__z); // x < y && y < z 3546*4684ddb6SLionel Sambuc __r = 1; 3547*4684ddb6SLionel Sambuc return __r; 3548*4684ddb6SLionel Sambuc } 3549*4684ddb6SLionel Sambuc swap(*__x, *__y); // x > y && y <= z 3550*4684ddb6SLionel Sambuc __r = 1; // x < y && x <= z 3551*4684ddb6SLionel Sambuc if (__c(*__z, *__y)) // if y > z 3552*4684ddb6SLionel Sambuc { 3553*4684ddb6SLionel Sambuc swap(*__y, *__z); // x <= y && y < z 3554*4684ddb6SLionel Sambuc __r = 2; 3555*4684ddb6SLionel Sambuc } 3556*4684ddb6SLionel Sambuc return __r; 3557*4684ddb6SLionel Sambuc} // x <= y && y <= z 3558*4684ddb6SLionel Sambuc 3559*4684ddb6SLionel Sambuc// stable, 3-6 compares, 0-5 swaps 3560*4684ddb6SLionel Sambuc 3561*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator> 3562*4684ddb6SLionel Sambucunsigned 3563*4684ddb6SLionel Sambuc__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 3564*4684ddb6SLionel Sambuc _ForwardIterator __x4, _Compare __c) 3565*4684ddb6SLionel Sambuc{ 3566*4684ddb6SLionel Sambuc unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c); 3567*4684ddb6SLionel Sambuc if (__c(*__x4, *__x3)) 3568*4684ddb6SLionel Sambuc { 3569*4684ddb6SLionel Sambuc swap(*__x3, *__x4); 3570*4684ddb6SLionel Sambuc ++__r; 3571*4684ddb6SLionel Sambuc if (__c(*__x3, *__x2)) 3572*4684ddb6SLionel Sambuc { 3573*4684ddb6SLionel Sambuc swap(*__x2, *__x3); 3574*4684ddb6SLionel Sambuc ++__r; 3575*4684ddb6SLionel Sambuc if (__c(*__x2, *__x1)) 3576*4684ddb6SLionel Sambuc { 3577*4684ddb6SLionel Sambuc swap(*__x1, *__x2); 3578*4684ddb6SLionel Sambuc ++__r; 3579*4684ddb6SLionel Sambuc } 3580*4684ddb6SLionel Sambuc } 3581*4684ddb6SLionel Sambuc } 3582*4684ddb6SLionel Sambuc return __r; 3583*4684ddb6SLionel Sambuc} 3584*4684ddb6SLionel Sambuc 3585*4684ddb6SLionel Sambuc// stable, 4-10 compares, 0-9 swaps 3586*4684ddb6SLionel Sambuc 3587*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator> 3588*4684ddb6SLionel Sambucunsigned 3589*4684ddb6SLionel Sambuc__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, 3590*4684ddb6SLionel Sambuc _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c) 3591*4684ddb6SLionel Sambuc{ 3592*4684ddb6SLionel Sambuc unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c); 3593*4684ddb6SLionel Sambuc if (__c(*__x5, *__x4)) 3594*4684ddb6SLionel Sambuc { 3595*4684ddb6SLionel Sambuc swap(*__x4, *__x5); 3596*4684ddb6SLionel Sambuc ++__r; 3597*4684ddb6SLionel Sambuc if (__c(*__x4, *__x3)) 3598*4684ddb6SLionel Sambuc { 3599*4684ddb6SLionel Sambuc swap(*__x3, *__x4); 3600*4684ddb6SLionel Sambuc ++__r; 3601*4684ddb6SLionel Sambuc if (__c(*__x3, *__x2)) 3602*4684ddb6SLionel Sambuc { 3603*4684ddb6SLionel Sambuc swap(*__x2, *__x3); 3604*4684ddb6SLionel Sambuc ++__r; 3605*4684ddb6SLionel Sambuc if (__c(*__x2, *__x1)) 3606*4684ddb6SLionel Sambuc { 3607*4684ddb6SLionel Sambuc swap(*__x1, *__x2); 3608*4684ddb6SLionel Sambuc ++__r; 3609*4684ddb6SLionel Sambuc } 3610*4684ddb6SLionel Sambuc } 3611*4684ddb6SLionel Sambuc } 3612*4684ddb6SLionel Sambuc } 3613*4684ddb6SLionel Sambuc return __r; 3614*4684ddb6SLionel Sambuc} 3615*4684ddb6SLionel Sambuc 3616*4684ddb6SLionel Sambuc// Assumes size > 0 3617*4684ddb6SLionel Sambuctemplate <class _Compare, class _BirdirectionalIterator> 3618*4684ddb6SLionel Sambucvoid 3619*4684ddb6SLionel Sambuc__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 3620*4684ddb6SLionel Sambuc{ 3621*4684ddb6SLionel Sambuc _BirdirectionalIterator __lm1 = __last; 3622*4684ddb6SLionel Sambuc for (--__lm1; __first != __lm1; ++__first) 3623*4684ddb6SLionel Sambuc { 3624*4684ddb6SLionel Sambuc _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator, 3625*4684ddb6SLionel Sambuc typename add_lvalue_reference<_Compare>::type> 3626*4684ddb6SLionel Sambuc (__first, __last, __comp); 3627*4684ddb6SLionel Sambuc if (__i != __first) 3628*4684ddb6SLionel Sambuc swap(*__first, *__i); 3629*4684ddb6SLionel Sambuc } 3630*4684ddb6SLionel Sambuc} 3631*4684ddb6SLionel Sambuc 3632*4684ddb6SLionel Sambuctemplate <class _Compare, class _BirdirectionalIterator> 3633*4684ddb6SLionel Sambucvoid 3634*4684ddb6SLionel Sambuc__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp) 3635*4684ddb6SLionel Sambuc{ 3636*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 3637*4684ddb6SLionel Sambuc if (__first != __last) 3638*4684ddb6SLionel Sambuc { 3639*4684ddb6SLionel Sambuc _BirdirectionalIterator __i = __first; 3640*4684ddb6SLionel Sambuc for (++__i; __i != __last; ++__i) 3641*4684ddb6SLionel Sambuc { 3642*4684ddb6SLionel Sambuc _BirdirectionalIterator __j = __i; 3643*4684ddb6SLionel Sambuc value_type __t(_VSTD::move(*__j)); 3644*4684ddb6SLionel Sambuc for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j) 3645*4684ddb6SLionel Sambuc *__j = _VSTD::move(*__k); 3646*4684ddb6SLionel Sambuc *__j = _VSTD::move(__t); 3647*4684ddb6SLionel Sambuc } 3648*4684ddb6SLionel Sambuc } 3649*4684ddb6SLionel Sambuc} 3650*4684ddb6SLionel Sambuc 3651*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 3652*4684ddb6SLionel Sambucvoid 3653*4684ddb6SLionel Sambuc__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3654*4684ddb6SLionel Sambuc{ 3655*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 3656*4684ddb6SLionel Sambuc _RandomAccessIterator __j = __first+2; 3657*4684ddb6SLionel Sambuc __sort3<_Compare>(__first, __first+1, __j, __comp); 3658*4684ddb6SLionel Sambuc for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 3659*4684ddb6SLionel Sambuc { 3660*4684ddb6SLionel Sambuc if (__comp(*__i, *__j)) 3661*4684ddb6SLionel Sambuc { 3662*4684ddb6SLionel Sambuc value_type __t(_VSTD::move(*__i)); 3663*4684ddb6SLionel Sambuc _RandomAccessIterator __k = __j; 3664*4684ddb6SLionel Sambuc __j = __i; 3665*4684ddb6SLionel Sambuc do 3666*4684ddb6SLionel Sambuc { 3667*4684ddb6SLionel Sambuc *__j = _VSTD::move(*__k); 3668*4684ddb6SLionel Sambuc __j = __k; 3669*4684ddb6SLionel Sambuc } while (__j != __first && __comp(__t, *--__k)); 3670*4684ddb6SLionel Sambuc *__j = _VSTD::move(__t); 3671*4684ddb6SLionel Sambuc } 3672*4684ddb6SLionel Sambuc __j = __i; 3673*4684ddb6SLionel Sambuc } 3674*4684ddb6SLionel Sambuc} 3675*4684ddb6SLionel Sambuc 3676*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 3677*4684ddb6SLionel Sambucbool 3678*4684ddb6SLionel Sambuc__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3679*4684ddb6SLionel Sambuc{ 3680*4684ddb6SLionel Sambuc switch (__last - __first) 3681*4684ddb6SLionel Sambuc { 3682*4684ddb6SLionel Sambuc case 0: 3683*4684ddb6SLionel Sambuc case 1: 3684*4684ddb6SLionel Sambuc return true; 3685*4684ddb6SLionel Sambuc case 2: 3686*4684ddb6SLionel Sambuc if (__comp(*--__last, *__first)) 3687*4684ddb6SLionel Sambuc swap(*__first, *__last); 3688*4684ddb6SLionel Sambuc return true; 3689*4684ddb6SLionel Sambuc case 3: 3690*4684ddb6SLionel Sambuc _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 3691*4684ddb6SLionel Sambuc return true; 3692*4684ddb6SLionel Sambuc case 4: 3693*4684ddb6SLionel Sambuc _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 3694*4684ddb6SLionel Sambuc return true; 3695*4684ddb6SLionel Sambuc case 5: 3696*4684ddb6SLionel Sambuc _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 3697*4684ddb6SLionel Sambuc return true; 3698*4684ddb6SLionel Sambuc } 3699*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 3700*4684ddb6SLionel Sambuc _RandomAccessIterator __j = __first+2; 3701*4684ddb6SLionel Sambuc __sort3<_Compare>(__first, __first+1, __j, __comp); 3702*4684ddb6SLionel Sambuc const unsigned __limit = 8; 3703*4684ddb6SLionel Sambuc unsigned __count = 0; 3704*4684ddb6SLionel Sambuc for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i) 3705*4684ddb6SLionel Sambuc { 3706*4684ddb6SLionel Sambuc if (__comp(*__i, *__j)) 3707*4684ddb6SLionel Sambuc { 3708*4684ddb6SLionel Sambuc value_type __t(_VSTD::move(*__i)); 3709*4684ddb6SLionel Sambuc _RandomAccessIterator __k = __j; 3710*4684ddb6SLionel Sambuc __j = __i; 3711*4684ddb6SLionel Sambuc do 3712*4684ddb6SLionel Sambuc { 3713*4684ddb6SLionel Sambuc *__j = _VSTD::move(*__k); 3714*4684ddb6SLionel Sambuc __j = __k; 3715*4684ddb6SLionel Sambuc } while (__j != __first && __comp(__t, *--__k)); 3716*4684ddb6SLionel Sambuc *__j = _VSTD::move(__t); 3717*4684ddb6SLionel Sambuc if (++__count == __limit) 3718*4684ddb6SLionel Sambuc return ++__i == __last; 3719*4684ddb6SLionel Sambuc } 3720*4684ddb6SLionel Sambuc __j = __i; 3721*4684ddb6SLionel Sambuc } 3722*4684ddb6SLionel Sambuc return true; 3723*4684ddb6SLionel Sambuc} 3724*4684ddb6SLionel Sambuc 3725*4684ddb6SLionel Sambuctemplate <class _Compare, class _BirdirectionalIterator> 3726*4684ddb6SLionel Sambucvoid 3727*4684ddb6SLionel Sambuc__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1, 3728*4684ddb6SLionel Sambuc typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp) 3729*4684ddb6SLionel Sambuc{ 3730*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type; 3731*4684ddb6SLionel Sambuc if (__first1 != __last1) 3732*4684ddb6SLionel Sambuc { 3733*4684ddb6SLionel Sambuc __destruct_n __d(0); 3734*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h(__first2, __d); 3735*4684ddb6SLionel Sambuc value_type* __last2 = __first2; 3736*4684ddb6SLionel Sambuc ::new(__last2) value_type(_VSTD::move(*__first1)); 3737*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3738*4684ddb6SLionel Sambuc for (++__last2; ++__first1 != __last1; ++__last2) 3739*4684ddb6SLionel Sambuc { 3740*4684ddb6SLionel Sambuc value_type* __j2 = __last2; 3741*4684ddb6SLionel Sambuc value_type* __i2 = __j2; 3742*4684ddb6SLionel Sambuc if (__comp(*__first1, *--__i2)) 3743*4684ddb6SLionel Sambuc { 3744*4684ddb6SLionel Sambuc ::new(__j2) value_type(_VSTD::move(*__i2)); 3745*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3746*4684ddb6SLionel Sambuc for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2) 3747*4684ddb6SLionel Sambuc *__j2 = _VSTD::move(*__i2); 3748*4684ddb6SLionel Sambuc *__j2 = _VSTD::move(*__first1); 3749*4684ddb6SLionel Sambuc } 3750*4684ddb6SLionel Sambuc else 3751*4684ddb6SLionel Sambuc { 3752*4684ddb6SLionel Sambuc ::new(__j2) value_type(_VSTD::move(*__first1)); 3753*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 3754*4684ddb6SLionel Sambuc } 3755*4684ddb6SLionel Sambuc } 3756*4684ddb6SLionel Sambuc __h.release(); 3757*4684ddb6SLionel Sambuc } 3758*4684ddb6SLionel Sambuc} 3759*4684ddb6SLionel Sambuc 3760*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 3761*4684ddb6SLionel Sambucvoid 3762*4684ddb6SLionel Sambuc__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3763*4684ddb6SLionel Sambuc{ 3764*4684ddb6SLionel Sambuc // _Compare is known to be a reference type 3765*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 3766*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 3767*4684ddb6SLionel Sambuc const difference_type __limit = is_trivially_copy_constructible<value_type>::value && 3768*4684ddb6SLionel Sambuc is_trivially_copy_assignable<value_type>::value ? 30 : 6; 3769*4684ddb6SLionel Sambuc while (true) 3770*4684ddb6SLionel Sambuc { 3771*4684ddb6SLionel Sambuc __restart: 3772*4684ddb6SLionel Sambuc difference_type __len = __last - __first; 3773*4684ddb6SLionel Sambuc switch (__len) 3774*4684ddb6SLionel Sambuc { 3775*4684ddb6SLionel Sambuc case 0: 3776*4684ddb6SLionel Sambuc case 1: 3777*4684ddb6SLionel Sambuc return; 3778*4684ddb6SLionel Sambuc case 2: 3779*4684ddb6SLionel Sambuc if (__comp(*--__last, *__first)) 3780*4684ddb6SLionel Sambuc swap(*__first, *__last); 3781*4684ddb6SLionel Sambuc return; 3782*4684ddb6SLionel Sambuc case 3: 3783*4684ddb6SLionel Sambuc _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); 3784*4684ddb6SLionel Sambuc return; 3785*4684ddb6SLionel Sambuc case 4: 3786*4684ddb6SLionel Sambuc _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); 3787*4684ddb6SLionel Sambuc return; 3788*4684ddb6SLionel Sambuc case 5: 3789*4684ddb6SLionel Sambuc _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); 3790*4684ddb6SLionel Sambuc return; 3791*4684ddb6SLionel Sambuc } 3792*4684ddb6SLionel Sambuc if (__len <= __limit) 3793*4684ddb6SLionel Sambuc { 3794*4684ddb6SLionel Sambuc _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp); 3795*4684ddb6SLionel Sambuc return; 3796*4684ddb6SLionel Sambuc } 3797*4684ddb6SLionel Sambuc // __len > 5 3798*4684ddb6SLionel Sambuc _RandomAccessIterator __m = __first; 3799*4684ddb6SLionel Sambuc _RandomAccessIterator __lm1 = __last; 3800*4684ddb6SLionel Sambuc --__lm1; 3801*4684ddb6SLionel Sambuc unsigned __n_swaps; 3802*4684ddb6SLionel Sambuc { 3803*4684ddb6SLionel Sambuc difference_type __delta; 3804*4684ddb6SLionel Sambuc if (__len >= 1000) 3805*4684ddb6SLionel Sambuc { 3806*4684ddb6SLionel Sambuc __delta = __len/2; 3807*4684ddb6SLionel Sambuc __m += __delta; 3808*4684ddb6SLionel Sambuc __delta /= 2; 3809*4684ddb6SLionel Sambuc __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp); 3810*4684ddb6SLionel Sambuc } 3811*4684ddb6SLionel Sambuc else 3812*4684ddb6SLionel Sambuc { 3813*4684ddb6SLionel Sambuc __delta = __len/2; 3814*4684ddb6SLionel Sambuc __m += __delta; 3815*4684ddb6SLionel Sambuc __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp); 3816*4684ddb6SLionel Sambuc } 3817*4684ddb6SLionel Sambuc } 3818*4684ddb6SLionel Sambuc // *__m is median 3819*4684ddb6SLionel Sambuc // partition [__first, __m) < *__m and *__m <= [__m, __last) 3820*4684ddb6SLionel Sambuc // (this inhibits tossing elements equivalent to __m around unnecessarily) 3821*4684ddb6SLionel Sambuc _RandomAccessIterator __i = __first; 3822*4684ddb6SLionel Sambuc _RandomAccessIterator __j = __lm1; 3823*4684ddb6SLionel Sambuc // j points beyond range to be tested, *__m is known to be <= *__lm1 3824*4684ddb6SLionel Sambuc // The search going up is known to be guarded but the search coming down isn't. 3825*4684ddb6SLionel Sambuc // Prime the downward search with a guard. 3826*4684ddb6SLionel Sambuc if (!__comp(*__i, *__m)) // if *__first == *__m 3827*4684ddb6SLionel Sambuc { 3828*4684ddb6SLionel Sambuc // *__first == *__m, *__first doesn't go in first part 3829*4684ddb6SLionel Sambuc // manually guard downward moving __j against __i 3830*4684ddb6SLionel Sambuc while (true) 3831*4684ddb6SLionel Sambuc { 3832*4684ddb6SLionel Sambuc if (__i == --__j) 3833*4684ddb6SLionel Sambuc { 3834*4684ddb6SLionel Sambuc // *__first == *__m, *__m <= all other elements 3835*4684ddb6SLionel Sambuc // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 3836*4684ddb6SLionel Sambuc ++__i; // __first + 1 3837*4684ddb6SLionel Sambuc __j = __last; 3838*4684ddb6SLionel Sambuc if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 3839*4684ddb6SLionel Sambuc { 3840*4684ddb6SLionel Sambuc while (true) 3841*4684ddb6SLionel Sambuc { 3842*4684ddb6SLionel Sambuc if (__i == __j) 3843*4684ddb6SLionel Sambuc return; // [__first, __last) all equivalent elements 3844*4684ddb6SLionel Sambuc if (__comp(*__first, *__i)) 3845*4684ddb6SLionel Sambuc { 3846*4684ddb6SLionel Sambuc swap(*__i, *__j); 3847*4684ddb6SLionel Sambuc ++__n_swaps; 3848*4684ddb6SLionel Sambuc ++__i; 3849*4684ddb6SLionel Sambuc break; 3850*4684ddb6SLionel Sambuc } 3851*4684ddb6SLionel Sambuc ++__i; 3852*4684ddb6SLionel Sambuc } 3853*4684ddb6SLionel Sambuc } 3854*4684ddb6SLionel Sambuc // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 3855*4684ddb6SLionel Sambuc if (__i == __j) 3856*4684ddb6SLionel Sambuc return; 3857*4684ddb6SLionel Sambuc while (true) 3858*4684ddb6SLionel Sambuc { 3859*4684ddb6SLionel Sambuc while (!__comp(*__first, *__i)) 3860*4684ddb6SLionel Sambuc ++__i; 3861*4684ddb6SLionel Sambuc while (__comp(*__first, *--__j)) 3862*4684ddb6SLionel Sambuc ; 3863*4684ddb6SLionel Sambuc if (__i >= __j) 3864*4684ddb6SLionel Sambuc break; 3865*4684ddb6SLionel Sambuc swap(*__i, *__j); 3866*4684ddb6SLionel Sambuc ++__n_swaps; 3867*4684ddb6SLionel Sambuc ++__i; 3868*4684ddb6SLionel Sambuc } 3869*4684ddb6SLionel Sambuc // [__first, __i) == *__first and *__first < [__i, __last) 3870*4684ddb6SLionel Sambuc // The first part is sorted, sort the secod part 3871*4684ddb6SLionel Sambuc // _VSTD::__sort<_Compare>(__i, __last, __comp); 3872*4684ddb6SLionel Sambuc __first = __i; 3873*4684ddb6SLionel Sambuc goto __restart; 3874*4684ddb6SLionel Sambuc } 3875*4684ddb6SLionel Sambuc if (__comp(*__j, *__m)) 3876*4684ddb6SLionel Sambuc { 3877*4684ddb6SLionel Sambuc swap(*__i, *__j); 3878*4684ddb6SLionel Sambuc ++__n_swaps; 3879*4684ddb6SLionel Sambuc break; // found guard for downward moving __j, now use unguarded partition 3880*4684ddb6SLionel Sambuc } 3881*4684ddb6SLionel Sambuc } 3882*4684ddb6SLionel Sambuc } 3883*4684ddb6SLionel Sambuc // It is known that *__i < *__m 3884*4684ddb6SLionel Sambuc ++__i; 3885*4684ddb6SLionel Sambuc // j points beyond range to be tested, *__m is known to be <= *__lm1 3886*4684ddb6SLionel Sambuc // if not yet partitioned... 3887*4684ddb6SLionel Sambuc if (__i < __j) 3888*4684ddb6SLionel Sambuc { 3889*4684ddb6SLionel Sambuc // known that *(__i - 1) < *__m 3890*4684ddb6SLionel Sambuc // known that __i <= __m 3891*4684ddb6SLionel Sambuc while (true) 3892*4684ddb6SLionel Sambuc { 3893*4684ddb6SLionel Sambuc // __m still guards upward moving __i 3894*4684ddb6SLionel Sambuc while (__comp(*__i, *__m)) 3895*4684ddb6SLionel Sambuc ++__i; 3896*4684ddb6SLionel Sambuc // It is now known that a guard exists for downward moving __j 3897*4684ddb6SLionel Sambuc while (!__comp(*--__j, *__m)) 3898*4684ddb6SLionel Sambuc ; 3899*4684ddb6SLionel Sambuc if (__i > __j) 3900*4684ddb6SLionel Sambuc break; 3901*4684ddb6SLionel Sambuc swap(*__i, *__j); 3902*4684ddb6SLionel Sambuc ++__n_swaps; 3903*4684ddb6SLionel Sambuc // It is known that __m != __j 3904*4684ddb6SLionel Sambuc // If __m just moved, follow it 3905*4684ddb6SLionel Sambuc if (__m == __i) 3906*4684ddb6SLionel Sambuc __m = __j; 3907*4684ddb6SLionel Sambuc ++__i; 3908*4684ddb6SLionel Sambuc } 3909*4684ddb6SLionel Sambuc } 3910*4684ddb6SLionel Sambuc // [__first, __i) < *__m and *__m <= [__i, __last) 3911*4684ddb6SLionel Sambuc if (__i != __m && __comp(*__m, *__i)) 3912*4684ddb6SLionel Sambuc { 3913*4684ddb6SLionel Sambuc swap(*__i, *__m); 3914*4684ddb6SLionel Sambuc ++__n_swaps; 3915*4684ddb6SLionel Sambuc } 3916*4684ddb6SLionel Sambuc // [__first, __i) < *__i and *__i <= [__i+1, __last) 3917*4684ddb6SLionel Sambuc // If we were given a perfect partition, see if insertion sort is quick... 3918*4684ddb6SLionel Sambuc if (__n_swaps == 0) 3919*4684ddb6SLionel Sambuc { 3920*4684ddb6SLionel Sambuc bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp); 3921*4684ddb6SLionel Sambuc if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp)) 3922*4684ddb6SLionel Sambuc { 3923*4684ddb6SLionel Sambuc if (__fs) 3924*4684ddb6SLionel Sambuc return; 3925*4684ddb6SLionel Sambuc __last = __i; 3926*4684ddb6SLionel Sambuc continue; 3927*4684ddb6SLionel Sambuc } 3928*4684ddb6SLionel Sambuc else 3929*4684ddb6SLionel Sambuc { 3930*4684ddb6SLionel Sambuc if (__fs) 3931*4684ddb6SLionel Sambuc { 3932*4684ddb6SLionel Sambuc __first = ++__i; 3933*4684ddb6SLionel Sambuc continue; 3934*4684ddb6SLionel Sambuc } 3935*4684ddb6SLionel Sambuc } 3936*4684ddb6SLionel Sambuc } 3937*4684ddb6SLionel Sambuc // sort smaller range with recursive call and larger with tail recursion elimination 3938*4684ddb6SLionel Sambuc if (__i - __first < __last - __i) 3939*4684ddb6SLionel Sambuc { 3940*4684ddb6SLionel Sambuc _VSTD::__sort<_Compare>(__first, __i, __comp); 3941*4684ddb6SLionel Sambuc // _VSTD::__sort<_Compare>(__i+1, __last, __comp); 3942*4684ddb6SLionel Sambuc __first = ++__i; 3943*4684ddb6SLionel Sambuc } 3944*4684ddb6SLionel Sambuc else 3945*4684ddb6SLionel Sambuc { 3946*4684ddb6SLionel Sambuc _VSTD::__sort<_Compare>(__i+1, __last, __comp); 3947*4684ddb6SLionel Sambuc // _VSTD::__sort<_Compare>(__first, __i, __comp); 3948*4684ddb6SLionel Sambuc __last = __i; 3949*4684ddb6SLionel Sambuc } 3950*4684ddb6SLionel Sambuc } 3951*4684ddb6SLionel Sambuc} 3952*4684ddb6SLionel Sambuc 3953*4684ddb6SLionel Sambuc// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare 3954*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 3955*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3956*4684ddb6SLionel Sambucvoid 3957*4684ddb6SLionel Sambucsort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 3958*4684ddb6SLionel Sambuc{ 3959*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 3960*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 3961*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 3962*4684ddb6SLionel Sambuc __sort<_Comp_ref>(__first, __last, __c); 3963*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 3964*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 3965*4684ddb6SLionel Sambuc __sort<_Comp_ref>(__first, __last, __comp); 3966*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 3967*4684ddb6SLionel Sambuc} 3968*4684ddb6SLionel Sambuc 3969*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 3970*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3971*4684ddb6SLionel Sambucvoid 3972*4684ddb6SLionel Sambucsort(_RandomAccessIterator __first, _RandomAccessIterator __last) 3973*4684ddb6SLionel Sambuc{ 3974*4684ddb6SLionel Sambuc _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 3975*4684ddb6SLionel Sambuc} 3976*4684ddb6SLionel Sambuc 3977*4684ddb6SLionel Sambuctemplate <class _Tp> 3978*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3979*4684ddb6SLionel Sambucvoid 3980*4684ddb6SLionel Sambucsort(_Tp** __first, _Tp** __last) 3981*4684ddb6SLionel Sambuc{ 3982*4684ddb6SLionel Sambuc _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>()); 3983*4684ddb6SLionel Sambuc} 3984*4684ddb6SLionel Sambuc 3985*4684ddb6SLionel Sambuctemplate <class _Tp> 3986*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3987*4684ddb6SLionel Sambucvoid 3988*4684ddb6SLionel Sambucsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last) 3989*4684ddb6SLionel Sambuc{ 3990*4684ddb6SLionel Sambuc _VSTD::sort(__first.base(), __last.base()); 3991*4684ddb6SLionel Sambuc} 3992*4684ddb6SLionel Sambuc 3993*4684ddb6SLionel Sambuctemplate <class _Tp, class _Compare> 3994*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 3995*4684ddb6SLionel Sambucvoid 3996*4684ddb6SLionel Sambucsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp) 3997*4684ddb6SLionel Sambuc{ 3998*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 3999*4684ddb6SLionel Sambuc _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp); 4000*4684ddb6SLionel Sambuc} 4001*4684ddb6SLionel Sambuc 4002*4684ddb6SLionel Sambuc#ifdef _LIBCPP_MSVC 4003*4684ddb6SLionel Sambuc#pragma warning( push ) 4004*4684ddb6SLionel Sambuc#pragma warning( disable: 4231) 4005*4684ddb6SLionel Sambuc#endif // _LIBCPP_MSVC 4006*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&)) 4007*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 4008*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 4009*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 4010*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&)) 4011*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 4012*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&)) 4013*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 4014*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&)) 4015*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 4016*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 4017*4684ddb6SLionel Sambuc_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>&)) 4018*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&)) 4019*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&)) 4020*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 4021*4684ddb6SLionel Sambuc 4022*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&)) 4023*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&)) 4024*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&)) 4025*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&)) 4026*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&)) 4027*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&)) 4028*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&)) 4029*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&)) 4030*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&)) 4031*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&)) 4032*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&)) 4033*4684ddb6SLionel Sambuc_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>&)) 4034*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&)) 4035*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&)) 4036*4684ddb6SLionel Sambuc_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&)) 4037*4684ddb6SLionel Sambuc 4038*4684ddb6SLionel Sambuc_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>&)) 4039*4684ddb6SLionel Sambuc#ifdef _LIBCPP_MSVC 4040*4684ddb6SLionel Sambuc#pragma warning( pop ) 4041*4684ddb6SLionel Sambuc#endif // _LIBCPP_MSVC 4042*4684ddb6SLionel Sambuc 4043*4684ddb6SLionel Sambuc// lower_bound 4044*4684ddb6SLionel Sambuc 4045*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator, class _Tp> 4046*4684ddb6SLionel Sambuc_ForwardIterator 4047*4684ddb6SLionel Sambuc__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4048*4684ddb6SLionel Sambuc{ 4049*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 4050*4684ddb6SLionel Sambuc difference_type __len = _VSTD::distance(__first, __last); 4051*4684ddb6SLionel Sambuc while (__len != 0) 4052*4684ddb6SLionel Sambuc { 4053*4684ddb6SLionel Sambuc difference_type __l2 = __len / 2; 4054*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 4055*4684ddb6SLionel Sambuc _VSTD::advance(__m, __l2); 4056*4684ddb6SLionel Sambuc if (__comp(*__m, __value_)) 4057*4684ddb6SLionel Sambuc { 4058*4684ddb6SLionel Sambuc __first = ++__m; 4059*4684ddb6SLionel Sambuc __len -= __l2 + 1; 4060*4684ddb6SLionel Sambuc } 4061*4684ddb6SLionel Sambuc else 4062*4684ddb6SLionel Sambuc __len = __l2; 4063*4684ddb6SLionel Sambuc } 4064*4684ddb6SLionel Sambuc return __first; 4065*4684ddb6SLionel Sambuc} 4066*4684ddb6SLionel Sambuc 4067*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp, class _Compare> 4068*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4069*4684ddb6SLionel Sambuc_ForwardIterator 4070*4684ddb6SLionel Sambuclower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4071*4684ddb6SLionel Sambuc{ 4072*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4073*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4074*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4075*4684ddb6SLionel Sambuc return __lower_bound<_Comp_ref>(__first, __last, __value_, __c); 4076*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4077*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4078*4684ddb6SLionel Sambuc return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp); 4079*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4080*4684ddb6SLionel Sambuc} 4081*4684ddb6SLionel Sambuc 4082*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 4083*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4084*4684ddb6SLionel Sambuc_ForwardIterator 4085*4684ddb6SLionel Sambuclower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4086*4684ddb6SLionel Sambuc{ 4087*4684ddb6SLionel Sambuc return _VSTD::lower_bound(__first, __last, __value_, 4088*4684ddb6SLionel Sambuc __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 4089*4684ddb6SLionel Sambuc} 4090*4684ddb6SLionel Sambuc 4091*4684ddb6SLionel Sambuc// upper_bound 4092*4684ddb6SLionel Sambuc 4093*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator, class _Tp> 4094*4684ddb6SLionel Sambuc_ForwardIterator 4095*4684ddb6SLionel Sambuc__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4096*4684ddb6SLionel Sambuc{ 4097*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 4098*4684ddb6SLionel Sambuc difference_type __len = _VSTD::distance(__first, __last); 4099*4684ddb6SLionel Sambuc while (__len != 0) 4100*4684ddb6SLionel Sambuc { 4101*4684ddb6SLionel Sambuc difference_type __l2 = __len / 2; 4102*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 4103*4684ddb6SLionel Sambuc _VSTD::advance(__m, __l2); 4104*4684ddb6SLionel Sambuc if (__comp(__value_, *__m)) 4105*4684ddb6SLionel Sambuc __len = __l2; 4106*4684ddb6SLionel Sambuc else 4107*4684ddb6SLionel Sambuc { 4108*4684ddb6SLionel Sambuc __first = ++__m; 4109*4684ddb6SLionel Sambuc __len -= __l2 + 1; 4110*4684ddb6SLionel Sambuc } 4111*4684ddb6SLionel Sambuc } 4112*4684ddb6SLionel Sambuc return __first; 4113*4684ddb6SLionel Sambuc} 4114*4684ddb6SLionel Sambuc 4115*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp, class _Compare> 4116*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4117*4684ddb6SLionel Sambuc_ForwardIterator 4118*4684ddb6SLionel Sambucupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4119*4684ddb6SLionel Sambuc{ 4120*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4121*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4122*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4123*4684ddb6SLionel Sambuc return __upper_bound<_Comp_ref>(__first, __last, __value_, __c); 4124*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4125*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4126*4684ddb6SLionel Sambuc return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp); 4127*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4128*4684ddb6SLionel Sambuc} 4129*4684ddb6SLionel Sambuc 4130*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 4131*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4132*4684ddb6SLionel Sambuc_ForwardIterator 4133*4684ddb6SLionel Sambucupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4134*4684ddb6SLionel Sambuc{ 4135*4684ddb6SLionel Sambuc return _VSTD::upper_bound(__first, __last, __value_, 4136*4684ddb6SLionel Sambuc __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>()); 4137*4684ddb6SLionel Sambuc} 4138*4684ddb6SLionel Sambuc 4139*4684ddb6SLionel Sambuc// equal_range 4140*4684ddb6SLionel Sambuc 4141*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator, class _Tp> 4142*4684ddb6SLionel Sambucpair<_ForwardIterator, _ForwardIterator> 4143*4684ddb6SLionel Sambuc__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4144*4684ddb6SLionel Sambuc{ 4145*4684ddb6SLionel Sambuc typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; 4146*4684ddb6SLionel Sambuc difference_type __len = _VSTD::distance(__first, __last); 4147*4684ddb6SLionel Sambuc while (__len != 0) 4148*4684ddb6SLionel Sambuc { 4149*4684ddb6SLionel Sambuc difference_type __l2 = __len / 2; 4150*4684ddb6SLionel Sambuc _ForwardIterator __m = __first; 4151*4684ddb6SLionel Sambuc _VSTD::advance(__m, __l2); 4152*4684ddb6SLionel Sambuc if (__comp(*__m, __value_)) 4153*4684ddb6SLionel Sambuc { 4154*4684ddb6SLionel Sambuc __first = ++__m; 4155*4684ddb6SLionel Sambuc __len -= __l2 + 1; 4156*4684ddb6SLionel Sambuc } 4157*4684ddb6SLionel Sambuc else if (__comp(__value_, *__m)) 4158*4684ddb6SLionel Sambuc { 4159*4684ddb6SLionel Sambuc __last = __m; 4160*4684ddb6SLionel Sambuc __len = __l2; 4161*4684ddb6SLionel Sambuc } 4162*4684ddb6SLionel Sambuc else 4163*4684ddb6SLionel Sambuc { 4164*4684ddb6SLionel Sambuc _ForwardIterator __mp1 = __m; 4165*4684ddb6SLionel Sambuc return pair<_ForwardIterator, _ForwardIterator> 4166*4684ddb6SLionel Sambuc ( 4167*4684ddb6SLionel Sambuc __lower_bound<_Compare>(__first, __m, __value_, __comp), 4168*4684ddb6SLionel Sambuc __upper_bound<_Compare>(++__mp1, __last, __value_, __comp) 4169*4684ddb6SLionel Sambuc ); 4170*4684ddb6SLionel Sambuc } 4171*4684ddb6SLionel Sambuc } 4172*4684ddb6SLionel Sambuc return pair<_ForwardIterator, _ForwardIterator>(__first, __first); 4173*4684ddb6SLionel Sambuc} 4174*4684ddb6SLionel Sambuc 4175*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp, class _Compare> 4176*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4177*4684ddb6SLionel Sambucpair<_ForwardIterator, _ForwardIterator> 4178*4684ddb6SLionel Sambucequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4179*4684ddb6SLionel Sambuc{ 4180*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4181*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4182*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4183*4684ddb6SLionel Sambuc return __equal_range<_Comp_ref>(__first, __last, __value_, __c); 4184*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4185*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4186*4684ddb6SLionel Sambuc return __equal_range<_Comp_ref>(__first, __last, __value_, __comp); 4187*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4188*4684ddb6SLionel Sambuc} 4189*4684ddb6SLionel Sambuc 4190*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 4191*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4192*4684ddb6SLionel Sambucpair<_ForwardIterator, _ForwardIterator> 4193*4684ddb6SLionel Sambucequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4194*4684ddb6SLionel Sambuc{ 4195*4684ddb6SLionel Sambuc return _VSTD::equal_range(__first, __last, __value_, 4196*4684ddb6SLionel Sambuc __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 4197*4684ddb6SLionel Sambuc} 4198*4684ddb6SLionel Sambuc 4199*4684ddb6SLionel Sambuc// binary_search 4200*4684ddb6SLionel Sambuc 4201*4684ddb6SLionel Sambuctemplate <class _Compare, class _ForwardIterator, class _Tp> 4202*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4203*4684ddb6SLionel Sambucbool 4204*4684ddb6SLionel Sambuc__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4205*4684ddb6SLionel Sambuc{ 4206*4684ddb6SLionel Sambuc __first = __lower_bound<_Compare>(__first, __last, __value_, __comp); 4207*4684ddb6SLionel Sambuc return __first != __last && !__comp(__value_, *__first); 4208*4684ddb6SLionel Sambuc} 4209*4684ddb6SLionel Sambuc 4210*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp, class _Compare> 4211*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4212*4684ddb6SLionel Sambucbool 4213*4684ddb6SLionel Sambucbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) 4214*4684ddb6SLionel Sambuc{ 4215*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4216*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4217*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4218*4684ddb6SLionel Sambuc return __binary_search<_Comp_ref>(__first, __last, __value_, __c); 4219*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4220*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4221*4684ddb6SLionel Sambuc return __binary_search<_Comp_ref>(__first, __last, __value_, __comp); 4222*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4223*4684ddb6SLionel Sambuc} 4224*4684ddb6SLionel Sambuc 4225*4684ddb6SLionel Sambuctemplate <class _ForwardIterator, class _Tp> 4226*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4227*4684ddb6SLionel Sambucbool 4228*4684ddb6SLionel Sambucbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) 4229*4684ddb6SLionel Sambuc{ 4230*4684ddb6SLionel Sambuc return _VSTD::binary_search(__first, __last, __value_, 4231*4684ddb6SLionel Sambuc __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>()); 4232*4684ddb6SLionel Sambuc} 4233*4684ddb6SLionel Sambuc 4234*4684ddb6SLionel Sambuc// merge 4235*4684ddb6SLionel Sambuc 4236*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 4237*4684ddb6SLionel Sambuc_OutputIterator 4238*4684ddb6SLionel Sambuc__merge(_InputIterator1 __first1, _InputIterator1 __last1, 4239*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 4240*4684ddb6SLionel Sambuc{ 4241*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__result) 4242*4684ddb6SLionel Sambuc { 4243*4684ddb6SLionel Sambuc if (__first2 == __last2) 4244*4684ddb6SLionel Sambuc return _VSTD::copy(__first1, __last1, __result); 4245*4684ddb6SLionel Sambuc if (__comp(*__first2, *__first1)) 4246*4684ddb6SLionel Sambuc { 4247*4684ddb6SLionel Sambuc *__result = *__first2; 4248*4684ddb6SLionel Sambuc ++__first2; 4249*4684ddb6SLionel Sambuc } 4250*4684ddb6SLionel Sambuc else 4251*4684ddb6SLionel Sambuc { 4252*4684ddb6SLionel Sambuc *__result = *__first1; 4253*4684ddb6SLionel Sambuc ++__first1; 4254*4684ddb6SLionel Sambuc } 4255*4684ddb6SLionel Sambuc } 4256*4684ddb6SLionel Sambuc return _VSTD::copy(__first2, __last2, __result); 4257*4684ddb6SLionel Sambuc} 4258*4684ddb6SLionel Sambuc 4259*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 4260*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4261*4684ddb6SLionel Sambuc_OutputIterator 4262*4684ddb6SLionel Sambucmerge(_InputIterator1 __first1, _InputIterator1 __last1, 4263*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 4264*4684ddb6SLionel Sambuc{ 4265*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4266*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4267*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4268*4684ddb6SLionel Sambuc return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 4269*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4270*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4271*4684ddb6SLionel Sambuc return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 4272*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4273*4684ddb6SLionel Sambuc} 4274*4684ddb6SLionel Sambuc 4275*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 4276*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4277*4684ddb6SLionel Sambuc_OutputIterator 4278*4684ddb6SLionel Sambucmerge(_InputIterator1 __first1, _InputIterator1 __last1, 4279*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 4280*4684ddb6SLionel Sambuc{ 4281*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator1>::value_type __v1; 4282*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator2>::value_type __v2; 4283*4684ddb6SLionel Sambuc return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>()); 4284*4684ddb6SLionel Sambuc} 4285*4684ddb6SLionel Sambuc 4286*4684ddb6SLionel Sambuc// inplace_merge 4287*4684ddb6SLionel Sambuc 4288*4684ddb6SLionel Sambuctemplate <class _Compare, class _BidirectionalIterator> 4289*4684ddb6SLionel Sambucvoid 4290*4684ddb6SLionel Sambuc__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 4291*4684ddb6SLionel Sambuc _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 4292*4684ddb6SLionel Sambuc typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 4293*4684ddb6SLionel Sambuc typename iterator_traits<_BidirectionalIterator>::value_type* __buff) 4294*4684ddb6SLionel Sambuc{ 4295*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 4296*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 4297*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::pointer pointer; 4298*4684ddb6SLionel Sambuc __destruct_n __d(0); 4299*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 4300*4684ddb6SLionel Sambuc if (__len1 <= __len2) 4301*4684ddb6SLionel Sambuc { 4302*4684ddb6SLionel Sambuc value_type* __p = __buff; 4303*4684ddb6SLionel Sambuc for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), ++__i, ++__p) 4304*4684ddb6SLionel Sambuc ::new(__p) value_type(_VSTD::move(*__i)); 4305*4684ddb6SLionel Sambuc __merge<_Compare>(move_iterator<value_type*>(__buff), 4306*4684ddb6SLionel Sambuc move_iterator<value_type*>(__p), 4307*4684ddb6SLionel Sambuc move_iterator<_BidirectionalIterator>(__middle), 4308*4684ddb6SLionel Sambuc move_iterator<_BidirectionalIterator>(__last), 4309*4684ddb6SLionel Sambuc __first, __comp); 4310*4684ddb6SLionel Sambuc } 4311*4684ddb6SLionel Sambuc else 4312*4684ddb6SLionel Sambuc { 4313*4684ddb6SLionel Sambuc value_type* __p = __buff; 4314*4684ddb6SLionel Sambuc for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), ++__i, ++__p) 4315*4684ddb6SLionel Sambuc ::new(__p) value_type(_VSTD::move(*__i)); 4316*4684ddb6SLionel Sambuc typedef reverse_iterator<_BidirectionalIterator> _RBi; 4317*4684ddb6SLionel Sambuc typedef reverse_iterator<value_type*> _Rv; 4318*4684ddb6SLionel Sambuc __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)), 4319*4684ddb6SLionel Sambuc move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)), 4320*4684ddb6SLionel Sambuc _RBi(__last), __negate<_Compare>(__comp)); 4321*4684ddb6SLionel Sambuc } 4322*4684ddb6SLionel Sambuc} 4323*4684ddb6SLionel Sambuc 4324*4684ddb6SLionel Sambuctemplate <class _Compare, class _BidirectionalIterator> 4325*4684ddb6SLionel Sambucvoid 4326*4684ddb6SLionel Sambuc__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 4327*4684ddb6SLionel Sambuc _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1, 4328*4684ddb6SLionel Sambuc typename iterator_traits<_BidirectionalIterator>::difference_type __len2, 4329*4684ddb6SLionel Sambuc typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size) 4330*4684ddb6SLionel Sambuc{ 4331*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 4332*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 4333*4684ddb6SLionel Sambuc while (true) 4334*4684ddb6SLionel Sambuc { 4335*4684ddb6SLionel Sambuc // if __middle == __last, we're done 4336*4684ddb6SLionel Sambuc if (__len2 == 0) 4337*4684ddb6SLionel Sambuc return; 4338*4684ddb6SLionel Sambuc // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0 4339*4684ddb6SLionel Sambuc for (; true; ++__first, --__len1) 4340*4684ddb6SLionel Sambuc { 4341*4684ddb6SLionel Sambuc if (__len1 == 0) 4342*4684ddb6SLionel Sambuc return; 4343*4684ddb6SLionel Sambuc if (__comp(*__middle, *__first)) 4344*4684ddb6SLionel Sambuc break; 4345*4684ddb6SLionel Sambuc } 4346*4684ddb6SLionel Sambuc if (__len1 <= __buff_size || __len2 <= __buff_size) 4347*4684ddb6SLionel Sambuc { 4348*4684ddb6SLionel Sambuc __buffered_inplace_merge<_Compare>(__first, __middle, __last, __comp, __len1, __len2, __buff); 4349*4684ddb6SLionel Sambuc return; 4350*4684ddb6SLionel Sambuc } 4351*4684ddb6SLionel Sambuc // __first < __middle < __last 4352*4684ddb6SLionel Sambuc // *__first > *__middle 4353*4684ddb6SLionel Sambuc // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that 4354*4684ddb6SLionel Sambuc // all elements in: 4355*4684ddb6SLionel Sambuc // [__first, __m1) <= [__middle, __m2) 4356*4684ddb6SLionel Sambuc // [__middle, __m2) < [__m1, __middle) 4357*4684ddb6SLionel Sambuc // [__m1, __middle) <= [__m2, __last) 4358*4684ddb6SLionel Sambuc // and __m1 or __m2 is in the middle of its range 4359*4684ddb6SLionel Sambuc _BidirectionalIterator __m1; // "median" of [__first, __middle) 4360*4684ddb6SLionel Sambuc _BidirectionalIterator __m2; // "median" of [__middle, __last) 4361*4684ddb6SLionel Sambuc difference_type __len11; // distance(__first, __m1) 4362*4684ddb6SLionel Sambuc difference_type __len21; // distance(__middle, __m2) 4363*4684ddb6SLionel Sambuc // binary search smaller range 4364*4684ddb6SLionel Sambuc if (__len1 < __len2) 4365*4684ddb6SLionel Sambuc { // __len >= 1, __len2 >= 2 4366*4684ddb6SLionel Sambuc __len21 = __len2 / 2; 4367*4684ddb6SLionel Sambuc __m2 = __middle; 4368*4684ddb6SLionel Sambuc _VSTD::advance(__m2, __len21); 4369*4684ddb6SLionel Sambuc __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp); 4370*4684ddb6SLionel Sambuc __len11 = _VSTD::distance(__first, __m1); 4371*4684ddb6SLionel Sambuc } 4372*4684ddb6SLionel Sambuc else 4373*4684ddb6SLionel Sambuc { 4374*4684ddb6SLionel Sambuc if (__len1 == 1) 4375*4684ddb6SLionel Sambuc { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1 4376*4684ddb6SLionel Sambuc // It is known *__first > *__middle 4377*4684ddb6SLionel Sambuc swap(*__first, *__middle); 4378*4684ddb6SLionel Sambuc return; 4379*4684ddb6SLionel Sambuc } 4380*4684ddb6SLionel Sambuc // __len1 >= 2, __len2 >= 1 4381*4684ddb6SLionel Sambuc __len11 = __len1 / 2; 4382*4684ddb6SLionel Sambuc __m1 = __first; 4383*4684ddb6SLionel Sambuc _VSTD::advance(__m1, __len11); 4384*4684ddb6SLionel Sambuc __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp); 4385*4684ddb6SLionel Sambuc __len21 = _VSTD::distance(__middle, __m2); 4386*4684ddb6SLionel Sambuc } 4387*4684ddb6SLionel Sambuc difference_type __len12 = __len1 - __len11; // distance(__m1, __middle) 4388*4684ddb6SLionel Sambuc difference_type __len22 = __len2 - __len21; // distance(__m2, __last) 4389*4684ddb6SLionel Sambuc // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) 4390*4684ddb6SLionel Sambuc // swap middle two partitions 4391*4684ddb6SLionel Sambuc __middle = _VSTD::rotate(__m1, __middle, __m2); 4392*4684ddb6SLionel Sambuc // __len12 and __len21 now have swapped meanings 4393*4684ddb6SLionel Sambuc // merge smaller range with recurisve call and larger with tail recursion elimination 4394*4684ddb6SLionel Sambuc if (__len11 + __len21 < __len12 + __len22) 4395*4684ddb6SLionel Sambuc { 4396*4684ddb6SLionel Sambuc __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 4397*4684ddb6SLionel Sambuc// __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 4398*4684ddb6SLionel Sambuc __first = __middle; 4399*4684ddb6SLionel Sambuc __middle = __m2; 4400*4684ddb6SLionel Sambuc __len1 = __len12; 4401*4684ddb6SLionel Sambuc __len2 = __len22; 4402*4684ddb6SLionel Sambuc } 4403*4684ddb6SLionel Sambuc else 4404*4684ddb6SLionel Sambuc { 4405*4684ddb6SLionel Sambuc __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size); 4406*4684ddb6SLionel Sambuc// __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size); 4407*4684ddb6SLionel Sambuc __last = __middle; 4408*4684ddb6SLionel Sambuc __middle = __m1; 4409*4684ddb6SLionel Sambuc __len1 = __len11; 4410*4684ddb6SLionel Sambuc __len2 = __len21; 4411*4684ddb6SLionel Sambuc } 4412*4684ddb6SLionel Sambuc } 4413*4684ddb6SLionel Sambuc} 4414*4684ddb6SLionel Sambuc 4415*4684ddb6SLionel Sambuctemplate <class _Tp> 4416*4684ddb6SLionel Sambucstruct __inplace_merge_switch 4417*4684ddb6SLionel Sambuc{ 4418*4684ddb6SLionel Sambuc static const unsigned value = is_trivially_copy_assignable<_Tp>::value; 4419*4684ddb6SLionel Sambuc}; 4420*4684ddb6SLionel Sambuc 4421*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator, class _Compare> 4422*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4423*4684ddb6SLionel Sambucvoid 4424*4684ddb6SLionel Sambucinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, 4425*4684ddb6SLionel Sambuc _Compare __comp) 4426*4684ddb6SLionel Sambuc{ 4427*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; 4428*4684ddb6SLionel Sambuc typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; 4429*4684ddb6SLionel Sambuc difference_type __len1 = _VSTD::distance(__first, __middle); 4430*4684ddb6SLionel Sambuc difference_type __len2 = _VSTD::distance(__middle, __last); 4431*4684ddb6SLionel Sambuc difference_type __buf_size = _VSTD::min(__len1, __len2); 4432*4684ddb6SLionel Sambuc pair<value_type*, ptrdiff_t> __buf(0, 0); 4433*4684ddb6SLionel Sambuc unique_ptr<value_type, __return_temporary_buffer> __h; 4434*4684ddb6SLionel Sambuc if (__inplace_merge_switch<value_type>::value && __buf_size > 8) 4435*4684ddb6SLionel Sambuc { 4436*4684ddb6SLionel Sambuc __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size); 4437*4684ddb6SLionel Sambuc __h.reset(__buf.first); 4438*4684ddb6SLionel Sambuc } 4439*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4440*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4441*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4442*4684ddb6SLionel Sambuc return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2, 4443*4684ddb6SLionel Sambuc __buf.first, __buf.second); 4444*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4445*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4446*4684ddb6SLionel Sambuc return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2, 4447*4684ddb6SLionel Sambuc __buf.first, __buf.second); 4448*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4449*4684ddb6SLionel Sambuc} 4450*4684ddb6SLionel Sambuc 4451*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 4452*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4453*4684ddb6SLionel Sambucvoid 4454*4684ddb6SLionel Sambucinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) 4455*4684ddb6SLionel Sambuc{ 4456*4684ddb6SLionel Sambuc _VSTD::inplace_merge(__first, __middle, __last, 4457*4684ddb6SLionel Sambuc __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 4458*4684ddb6SLionel Sambuc} 4459*4684ddb6SLionel Sambuc 4460*4684ddb6SLionel Sambuc// stable_sort 4461*4684ddb6SLionel Sambuc 4462*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2> 4463*4684ddb6SLionel Sambucvoid 4464*4684ddb6SLionel Sambuc__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1, 4465*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, 4466*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp) 4467*4684ddb6SLionel Sambuc{ 4468*4684ddb6SLionel Sambuc typedef typename iterator_traits<_InputIterator1>::value_type value_type; 4469*4684ddb6SLionel Sambuc __destruct_n __d(0); 4470*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h(__result, __d); 4471*4684ddb6SLionel Sambuc for (; true; ++__result) 4472*4684ddb6SLionel Sambuc { 4473*4684ddb6SLionel Sambuc if (__first1 == __last1) 4474*4684ddb6SLionel Sambuc { 4475*4684ddb6SLionel Sambuc for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0)) 4476*4684ddb6SLionel Sambuc ::new (__result) value_type(_VSTD::move(*__first2)); 4477*4684ddb6SLionel Sambuc __h.release(); 4478*4684ddb6SLionel Sambuc return; 4479*4684ddb6SLionel Sambuc } 4480*4684ddb6SLionel Sambuc if (__first2 == __last2) 4481*4684ddb6SLionel Sambuc { 4482*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0)) 4483*4684ddb6SLionel Sambuc ::new (__result) value_type(_VSTD::move(*__first1)); 4484*4684ddb6SLionel Sambuc __h.release(); 4485*4684ddb6SLionel Sambuc return; 4486*4684ddb6SLionel Sambuc } 4487*4684ddb6SLionel Sambuc if (__comp(*__first2, *__first1)) 4488*4684ddb6SLionel Sambuc { 4489*4684ddb6SLionel Sambuc ::new (__result) value_type(_VSTD::move(*__first2)); 4490*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 4491*4684ddb6SLionel Sambuc ++__first2; 4492*4684ddb6SLionel Sambuc } 4493*4684ddb6SLionel Sambuc else 4494*4684ddb6SLionel Sambuc { 4495*4684ddb6SLionel Sambuc ::new (__result) value_type(_VSTD::move(*__first1)); 4496*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 4497*4684ddb6SLionel Sambuc ++__first1; 4498*4684ddb6SLionel Sambuc } 4499*4684ddb6SLionel Sambuc } 4500*4684ddb6SLionel Sambuc} 4501*4684ddb6SLionel Sambuc 4502*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 4503*4684ddb6SLionel Sambucvoid 4504*4684ddb6SLionel Sambuc__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1, 4505*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, 4506*4684ddb6SLionel Sambuc _OutputIterator __result, _Compare __comp) 4507*4684ddb6SLionel Sambuc{ 4508*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__result) 4509*4684ddb6SLionel Sambuc { 4510*4684ddb6SLionel Sambuc if (__first2 == __last2) 4511*4684ddb6SLionel Sambuc { 4512*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__first1, ++__result) 4513*4684ddb6SLionel Sambuc *__result = _VSTD::move(*__first1); 4514*4684ddb6SLionel Sambuc return; 4515*4684ddb6SLionel Sambuc } 4516*4684ddb6SLionel Sambuc if (__comp(*__first2, *__first1)) 4517*4684ddb6SLionel Sambuc { 4518*4684ddb6SLionel Sambuc *__result = _VSTD::move(*__first2); 4519*4684ddb6SLionel Sambuc ++__first2; 4520*4684ddb6SLionel Sambuc } 4521*4684ddb6SLionel Sambuc else 4522*4684ddb6SLionel Sambuc { 4523*4684ddb6SLionel Sambuc *__result = _VSTD::move(*__first1); 4524*4684ddb6SLionel Sambuc ++__first1; 4525*4684ddb6SLionel Sambuc } 4526*4684ddb6SLionel Sambuc } 4527*4684ddb6SLionel Sambuc for (; __first2 != __last2; ++__first2, ++__result) 4528*4684ddb6SLionel Sambuc *__result = _VSTD::move(*__first2); 4529*4684ddb6SLionel Sambuc} 4530*4684ddb6SLionel Sambuc 4531*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4532*4684ddb6SLionel Sambucvoid 4533*4684ddb6SLionel Sambuc__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4534*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4535*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size); 4536*4684ddb6SLionel Sambuc 4537*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4538*4684ddb6SLionel Sambucvoid 4539*4684ddb6SLionel Sambuc__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp, 4540*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4541*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::value_type* __first2) 4542*4684ddb6SLionel Sambuc{ 4543*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4544*4684ddb6SLionel Sambuc switch (__len) 4545*4684ddb6SLionel Sambuc { 4546*4684ddb6SLionel Sambuc case 0: 4547*4684ddb6SLionel Sambuc return; 4548*4684ddb6SLionel Sambuc case 1: 4549*4684ddb6SLionel Sambuc ::new(__first2) value_type(_VSTD::move(*__first1)); 4550*4684ddb6SLionel Sambuc return; 4551*4684ddb6SLionel Sambuc case 2: 4552*4684ddb6SLionel Sambuc __destruct_n __d(0); 4553*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h2(__first2, __d); 4554*4684ddb6SLionel Sambuc if (__comp(*--__last1, *__first1)) 4555*4684ddb6SLionel Sambuc { 4556*4684ddb6SLionel Sambuc ::new(__first2) value_type(_VSTD::move(*__last1)); 4557*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 4558*4684ddb6SLionel Sambuc ++__first2; 4559*4684ddb6SLionel Sambuc ::new(__first2) value_type(_VSTD::move(*__first1)); 4560*4684ddb6SLionel Sambuc } 4561*4684ddb6SLionel Sambuc else 4562*4684ddb6SLionel Sambuc { 4563*4684ddb6SLionel Sambuc ::new(__first2) value_type(_VSTD::move(*__first1)); 4564*4684ddb6SLionel Sambuc __d.__incr((value_type*)0); 4565*4684ddb6SLionel Sambuc ++__first2; 4566*4684ddb6SLionel Sambuc ::new(__first2) value_type(_VSTD::move(*__last1)); 4567*4684ddb6SLionel Sambuc } 4568*4684ddb6SLionel Sambuc __h2.release(); 4569*4684ddb6SLionel Sambuc return; 4570*4684ddb6SLionel Sambuc } 4571*4684ddb6SLionel Sambuc if (__len <= 8) 4572*4684ddb6SLionel Sambuc { 4573*4684ddb6SLionel Sambuc __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp); 4574*4684ddb6SLionel Sambuc return; 4575*4684ddb6SLionel Sambuc } 4576*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 4577*4684ddb6SLionel Sambuc _RandomAccessIterator __m = __first1 + __l2; 4578*4684ddb6SLionel Sambuc __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2); 4579*4684ddb6SLionel Sambuc __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2); 4580*4684ddb6SLionel Sambuc __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp); 4581*4684ddb6SLionel Sambuc} 4582*4684ddb6SLionel Sambuc 4583*4684ddb6SLionel Sambuctemplate <class _Tp> 4584*4684ddb6SLionel Sambucstruct __stable_sort_switch 4585*4684ddb6SLionel Sambuc{ 4586*4684ddb6SLionel Sambuc static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value; 4587*4684ddb6SLionel Sambuc}; 4588*4684ddb6SLionel Sambuc 4589*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4590*4684ddb6SLionel Sambucvoid 4591*4684ddb6SLionel Sambuc__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4592*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len, 4593*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size) 4594*4684ddb6SLionel Sambuc{ 4595*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4596*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4597*4684ddb6SLionel Sambuc switch (__len) 4598*4684ddb6SLionel Sambuc { 4599*4684ddb6SLionel Sambuc case 0: 4600*4684ddb6SLionel Sambuc case 1: 4601*4684ddb6SLionel Sambuc return; 4602*4684ddb6SLionel Sambuc case 2: 4603*4684ddb6SLionel Sambuc if (__comp(*--__last, *__first)) 4604*4684ddb6SLionel Sambuc swap(*__first, *__last); 4605*4684ddb6SLionel Sambuc return; 4606*4684ddb6SLionel Sambuc } 4607*4684ddb6SLionel Sambuc if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 4608*4684ddb6SLionel Sambuc { 4609*4684ddb6SLionel Sambuc __insertion_sort<_Compare>(__first, __last, __comp); 4610*4684ddb6SLionel Sambuc return; 4611*4684ddb6SLionel Sambuc } 4612*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2; 4613*4684ddb6SLionel Sambuc _RandomAccessIterator __m = __first + __l2; 4614*4684ddb6SLionel Sambuc if (__len <= __buff_size) 4615*4684ddb6SLionel Sambuc { 4616*4684ddb6SLionel Sambuc __destruct_n __d(0); 4617*4684ddb6SLionel Sambuc unique_ptr<value_type, __destruct_n&> __h2(__buff, __d); 4618*4684ddb6SLionel Sambuc __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff); 4619*4684ddb6SLionel Sambuc __d.__set(__l2, (value_type*)0); 4620*4684ddb6SLionel Sambuc __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2); 4621*4684ddb6SLionel Sambuc __d.__set(__len, (value_type*)0); 4622*4684ddb6SLionel Sambuc __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp); 4623*4684ddb6SLionel Sambuc// __merge<_Compare>(move_iterator<value_type*>(__buff), 4624*4684ddb6SLionel Sambuc// move_iterator<value_type*>(__buff + __l2), 4625*4684ddb6SLionel Sambuc// move_iterator<_RandomAccessIterator>(__buff + __l2), 4626*4684ddb6SLionel Sambuc// move_iterator<_RandomAccessIterator>(__buff + __len), 4627*4684ddb6SLionel Sambuc// __first, __comp); 4628*4684ddb6SLionel Sambuc return; 4629*4684ddb6SLionel Sambuc } 4630*4684ddb6SLionel Sambuc __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size); 4631*4684ddb6SLionel Sambuc __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size); 4632*4684ddb6SLionel Sambuc __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size); 4633*4684ddb6SLionel Sambuc} 4634*4684ddb6SLionel Sambuc 4635*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4636*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4637*4684ddb6SLionel Sambucvoid 4638*4684ddb6SLionel Sambucstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4639*4684ddb6SLionel Sambuc{ 4640*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4641*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4642*4684ddb6SLionel Sambuc difference_type __len = __last - __first; 4643*4684ddb6SLionel Sambuc pair<value_type*, ptrdiff_t> __buf(0, 0); 4644*4684ddb6SLionel Sambuc unique_ptr<value_type, __return_temporary_buffer> __h; 4645*4684ddb6SLionel Sambuc if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) 4646*4684ddb6SLionel Sambuc { 4647*4684ddb6SLionel Sambuc __buf = _VSTD::get_temporary_buffer<value_type>(__len); 4648*4684ddb6SLionel Sambuc __h.reset(__buf.first); 4649*4684ddb6SLionel Sambuc } 4650*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4651*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4652*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4653*4684ddb6SLionel Sambuc __stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second); 4654*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4655*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4656*4684ddb6SLionel Sambuc __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second); 4657*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4658*4684ddb6SLionel Sambuc} 4659*4684ddb6SLionel Sambuc 4660*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 4661*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4662*4684ddb6SLionel Sambucvoid 4663*4684ddb6SLionel Sambucstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) 4664*4684ddb6SLionel Sambuc{ 4665*4684ddb6SLionel Sambuc _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4666*4684ddb6SLionel Sambuc} 4667*4684ddb6SLionel Sambuc 4668*4684ddb6SLionel Sambuc// is_heap_until 4669*4684ddb6SLionel Sambuc 4670*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4671*4684ddb6SLionel Sambuc_RandomAccessIterator 4672*4684ddb6SLionel Sambucis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4673*4684ddb6SLionel Sambuc{ 4674*4684ddb6SLionel Sambuc typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4675*4684ddb6SLionel Sambuc difference_type __len = __last - __first; 4676*4684ddb6SLionel Sambuc difference_type __p = 0; 4677*4684ddb6SLionel Sambuc difference_type __c = 1; 4678*4684ddb6SLionel Sambuc _RandomAccessIterator __pp = __first; 4679*4684ddb6SLionel Sambuc while (__c < __len) 4680*4684ddb6SLionel Sambuc { 4681*4684ddb6SLionel Sambuc _RandomAccessIterator __cp = __first + __c; 4682*4684ddb6SLionel Sambuc if (__comp(*__pp, *__cp)) 4683*4684ddb6SLionel Sambuc return __cp; 4684*4684ddb6SLionel Sambuc ++__c; 4685*4684ddb6SLionel Sambuc ++__cp; 4686*4684ddb6SLionel Sambuc if (__c == __len) 4687*4684ddb6SLionel Sambuc return __last; 4688*4684ddb6SLionel Sambuc if (__comp(*__pp, *__cp)) 4689*4684ddb6SLionel Sambuc return __cp; 4690*4684ddb6SLionel Sambuc ++__p; 4691*4684ddb6SLionel Sambuc ++__pp; 4692*4684ddb6SLionel Sambuc __c = 2 * __p + 1; 4693*4684ddb6SLionel Sambuc } 4694*4684ddb6SLionel Sambuc return __last; 4695*4684ddb6SLionel Sambuc} 4696*4684ddb6SLionel Sambuc 4697*4684ddb6SLionel Sambuctemplate<class _RandomAccessIterator> 4698*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4699*4684ddb6SLionel Sambuc_RandomAccessIterator 4700*4684ddb6SLionel Sambucis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) 4701*4684ddb6SLionel Sambuc{ 4702*4684ddb6SLionel Sambuc return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4703*4684ddb6SLionel Sambuc} 4704*4684ddb6SLionel Sambuc 4705*4684ddb6SLionel Sambuc// is_heap 4706*4684ddb6SLionel Sambuc 4707*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4708*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4709*4684ddb6SLionel Sambucbool 4710*4684ddb6SLionel Sambucis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4711*4684ddb6SLionel Sambuc{ 4712*4684ddb6SLionel Sambuc return _VSTD::is_heap_until(__first, __last, __comp) == __last; 4713*4684ddb6SLionel Sambuc} 4714*4684ddb6SLionel Sambuc 4715*4684ddb6SLionel Sambuctemplate<class _RandomAccessIterator> 4716*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4717*4684ddb6SLionel Sambucbool 4718*4684ddb6SLionel Sambucis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4719*4684ddb6SLionel Sambuc{ 4720*4684ddb6SLionel Sambuc return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4721*4684ddb6SLionel Sambuc} 4722*4684ddb6SLionel Sambuc 4723*4684ddb6SLionel Sambuc// push_heap 4724*4684ddb6SLionel Sambuc 4725*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4726*4684ddb6SLionel Sambucvoid 4727*4684ddb6SLionel Sambuc__push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare __comp, 4728*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len) 4729*4684ddb6SLionel Sambuc{ 4730*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4731*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4732*4684ddb6SLionel Sambuc if (__len > 1) 4733*4684ddb6SLionel Sambuc { 4734*4684ddb6SLionel Sambuc difference_type __p = 0; 4735*4684ddb6SLionel Sambuc _RandomAccessIterator __pp = __first; 4736*4684ddb6SLionel Sambuc difference_type __c = 2; 4737*4684ddb6SLionel Sambuc _RandomAccessIterator __cp = __first + __c; 4738*4684ddb6SLionel Sambuc if (__c == __len || __comp(*__cp, *(__cp - 1))) 4739*4684ddb6SLionel Sambuc { 4740*4684ddb6SLionel Sambuc --__c; 4741*4684ddb6SLionel Sambuc --__cp; 4742*4684ddb6SLionel Sambuc } 4743*4684ddb6SLionel Sambuc if (__comp(*__pp, *__cp)) 4744*4684ddb6SLionel Sambuc { 4745*4684ddb6SLionel Sambuc value_type __t(_VSTD::move(*__pp)); 4746*4684ddb6SLionel Sambuc do 4747*4684ddb6SLionel Sambuc { 4748*4684ddb6SLionel Sambuc *__pp = _VSTD::move(*__cp); 4749*4684ddb6SLionel Sambuc __pp = __cp; 4750*4684ddb6SLionel Sambuc __p = __c; 4751*4684ddb6SLionel Sambuc __c = (__p + 1) * 2; 4752*4684ddb6SLionel Sambuc if (__c > __len) 4753*4684ddb6SLionel Sambuc break; 4754*4684ddb6SLionel Sambuc __cp = __first + __c; 4755*4684ddb6SLionel Sambuc if (__c == __len || __comp(*__cp, *(__cp - 1))) 4756*4684ddb6SLionel Sambuc { 4757*4684ddb6SLionel Sambuc --__c; 4758*4684ddb6SLionel Sambuc --__cp; 4759*4684ddb6SLionel Sambuc } 4760*4684ddb6SLionel Sambuc } while (__comp(__t, *__cp)); 4761*4684ddb6SLionel Sambuc *__pp = _VSTD::move(__t); 4762*4684ddb6SLionel Sambuc } 4763*4684ddb6SLionel Sambuc } 4764*4684ddb6SLionel Sambuc} 4765*4684ddb6SLionel Sambuc 4766*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4767*4684ddb6SLionel Sambucvoid 4768*4684ddb6SLionel Sambuc__push_heap_back(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4769*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len) 4770*4684ddb6SLionel Sambuc{ 4771*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4772*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; 4773*4684ddb6SLionel Sambuc if (__len > 1) 4774*4684ddb6SLionel Sambuc { 4775*4684ddb6SLionel Sambuc __len = (__len - 2) / 2; 4776*4684ddb6SLionel Sambuc _RandomAccessIterator __ptr = __first + __len; 4777*4684ddb6SLionel Sambuc if (__comp(*__ptr, *--__last)) 4778*4684ddb6SLionel Sambuc { 4779*4684ddb6SLionel Sambuc value_type __t(_VSTD::move(*__last)); 4780*4684ddb6SLionel Sambuc do 4781*4684ddb6SLionel Sambuc { 4782*4684ddb6SLionel Sambuc *__last = _VSTD::move(*__ptr); 4783*4684ddb6SLionel Sambuc __last = __ptr; 4784*4684ddb6SLionel Sambuc if (__len == 0) 4785*4684ddb6SLionel Sambuc break; 4786*4684ddb6SLionel Sambuc __len = (__len - 1) / 2; 4787*4684ddb6SLionel Sambuc __ptr = __first + __len; 4788*4684ddb6SLionel Sambuc } while (__comp(*__ptr, __t)); 4789*4684ddb6SLionel Sambuc *__last = _VSTD::move(__t); 4790*4684ddb6SLionel Sambuc } 4791*4684ddb6SLionel Sambuc } 4792*4684ddb6SLionel Sambuc} 4793*4684ddb6SLionel Sambuc 4794*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4795*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4796*4684ddb6SLionel Sambucvoid 4797*4684ddb6SLionel Sambucpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4798*4684ddb6SLionel Sambuc{ 4799*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4800*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4801*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4802*4684ddb6SLionel Sambuc __push_heap_back<_Comp_ref>(__first, __last, __c, __last - __first); 4803*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4804*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4805*4684ddb6SLionel Sambuc __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first); 4806*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4807*4684ddb6SLionel Sambuc} 4808*4684ddb6SLionel Sambuc 4809*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 4810*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4811*4684ddb6SLionel Sambucvoid 4812*4684ddb6SLionel Sambucpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4813*4684ddb6SLionel Sambuc{ 4814*4684ddb6SLionel Sambuc _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4815*4684ddb6SLionel Sambuc} 4816*4684ddb6SLionel Sambuc 4817*4684ddb6SLionel Sambuc// pop_heap 4818*4684ddb6SLionel Sambuc 4819*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4820*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4821*4684ddb6SLionel Sambucvoid 4822*4684ddb6SLionel Sambuc__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, 4823*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len) 4824*4684ddb6SLionel Sambuc{ 4825*4684ddb6SLionel Sambuc if (__len > 1) 4826*4684ddb6SLionel Sambuc { 4827*4684ddb6SLionel Sambuc swap(*__first, *--__last); 4828*4684ddb6SLionel Sambuc __push_heap_front<_Compare>(__first, __last, __comp, __len-1); 4829*4684ddb6SLionel Sambuc } 4830*4684ddb6SLionel Sambuc} 4831*4684ddb6SLionel Sambuc 4832*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4833*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4834*4684ddb6SLionel Sambucvoid 4835*4684ddb6SLionel Sambucpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4836*4684ddb6SLionel Sambuc{ 4837*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4838*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4839*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4840*4684ddb6SLionel Sambuc __pop_heap<_Comp_ref>(__first, __last, __c, __last - __first); 4841*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4842*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4843*4684ddb6SLionel Sambuc __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first); 4844*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4845*4684ddb6SLionel Sambuc} 4846*4684ddb6SLionel Sambuc 4847*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 4848*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4849*4684ddb6SLionel Sambucvoid 4850*4684ddb6SLionel Sambucpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4851*4684ddb6SLionel Sambuc{ 4852*4684ddb6SLionel Sambuc _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4853*4684ddb6SLionel Sambuc} 4854*4684ddb6SLionel Sambuc 4855*4684ddb6SLionel Sambuc// make_heap 4856*4684ddb6SLionel Sambuc 4857*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4858*4684ddb6SLionel Sambucvoid 4859*4684ddb6SLionel Sambuc__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4860*4684ddb6SLionel Sambuc{ 4861*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4862*4684ddb6SLionel Sambuc difference_type __n = __last - __first; 4863*4684ddb6SLionel Sambuc if (__n > 1) 4864*4684ddb6SLionel Sambuc { 4865*4684ddb6SLionel Sambuc __last = __first; 4866*4684ddb6SLionel Sambuc ++__last; 4867*4684ddb6SLionel Sambuc for (difference_type __i = 1; __i < __n;) 4868*4684ddb6SLionel Sambuc __push_heap_back<_Compare>(__first, ++__last, __comp, ++__i); 4869*4684ddb6SLionel Sambuc } 4870*4684ddb6SLionel Sambuc} 4871*4684ddb6SLionel Sambuc 4872*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4873*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4874*4684ddb6SLionel Sambucvoid 4875*4684ddb6SLionel Sambucmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4876*4684ddb6SLionel Sambuc{ 4877*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4878*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4879*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4880*4684ddb6SLionel Sambuc __make_heap<_Comp_ref>(__first, __last, __c); 4881*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4882*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4883*4684ddb6SLionel Sambuc __make_heap<_Comp_ref>(__first, __last, __comp); 4884*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4885*4684ddb6SLionel Sambuc} 4886*4684ddb6SLionel Sambuc 4887*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 4888*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4889*4684ddb6SLionel Sambucvoid 4890*4684ddb6SLionel Sambucmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4891*4684ddb6SLionel Sambuc{ 4892*4684ddb6SLionel Sambuc _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4893*4684ddb6SLionel Sambuc} 4894*4684ddb6SLionel Sambuc 4895*4684ddb6SLionel Sambuc// sort_heap 4896*4684ddb6SLionel Sambuc 4897*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4898*4684ddb6SLionel Sambucvoid 4899*4684ddb6SLionel Sambuc__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4900*4684ddb6SLionel Sambuc{ 4901*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 4902*4684ddb6SLionel Sambuc for (difference_type __n = __last - __first; __n > 1; --__last, --__n) 4903*4684ddb6SLionel Sambuc __pop_heap<_Compare>(__first, __last, __comp, __n); 4904*4684ddb6SLionel Sambuc} 4905*4684ddb6SLionel Sambuc 4906*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4907*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4908*4684ddb6SLionel Sambucvoid 4909*4684ddb6SLionel Sambucsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) 4910*4684ddb6SLionel Sambuc{ 4911*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4912*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4913*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4914*4684ddb6SLionel Sambuc __sort_heap<_Comp_ref>(__first, __last, __c); 4915*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4916*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4917*4684ddb6SLionel Sambuc __sort_heap<_Comp_ref>(__first, __last, __comp); 4918*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4919*4684ddb6SLionel Sambuc} 4920*4684ddb6SLionel Sambuc 4921*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 4922*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4923*4684ddb6SLionel Sambucvoid 4924*4684ddb6SLionel Sambucsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) 4925*4684ddb6SLionel Sambuc{ 4926*4684ddb6SLionel Sambuc _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4927*4684ddb6SLionel Sambuc} 4928*4684ddb6SLionel Sambuc 4929*4684ddb6SLionel Sambuc// partial_sort 4930*4684ddb6SLionel Sambuc 4931*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 4932*4684ddb6SLionel Sambucvoid 4933*4684ddb6SLionel Sambuc__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 4934*4684ddb6SLionel Sambuc _Compare __comp) 4935*4684ddb6SLionel Sambuc{ 4936*4684ddb6SLionel Sambuc __make_heap<_Compare>(__first, __middle, __comp); 4937*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first; 4938*4684ddb6SLionel Sambuc for (_RandomAccessIterator __i = __middle; __i != __last; ++__i) 4939*4684ddb6SLionel Sambuc { 4940*4684ddb6SLionel Sambuc if (__comp(*__i, *__first)) 4941*4684ddb6SLionel Sambuc { 4942*4684ddb6SLionel Sambuc swap(*__i, *__first); 4943*4684ddb6SLionel Sambuc __push_heap_front<_Compare>(__first, __middle, __comp, __len); 4944*4684ddb6SLionel Sambuc } 4945*4684ddb6SLionel Sambuc } 4946*4684ddb6SLionel Sambuc __sort_heap<_Compare>(__first, __middle, __comp); 4947*4684ddb6SLionel Sambuc} 4948*4684ddb6SLionel Sambuc 4949*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 4950*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4951*4684ddb6SLionel Sambucvoid 4952*4684ddb6SLionel Sambucpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, 4953*4684ddb6SLionel Sambuc _Compare __comp) 4954*4684ddb6SLionel Sambuc{ 4955*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 4956*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 4957*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 4958*4684ddb6SLionel Sambuc __partial_sort<_Comp_ref>(__first, __middle, __last, __c); 4959*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 4960*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 4961*4684ddb6SLionel Sambuc __partial_sort<_Comp_ref>(__first, __middle, __last, __comp); 4962*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 4963*4684ddb6SLionel Sambuc} 4964*4684ddb6SLionel Sambuc 4965*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 4966*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 4967*4684ddb6SLionel Sambucvoid 4968*4684ddb6SLionel Sambucpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) 4969*4684ddb6SLionel Sambuc{ 4970*4684ddb6SLionel Sambuc _VSTD::partial_sort(__first, __middle, __last, 4971*4684ddb6SLionel Sambuc __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 4972*4684ddb6SLionel Sambuc} 4973*4684ddb6SLionel Sambuc 4974*4684ddb6SLionel Sambuc// partial_sort_copy 4975*4684ddb6SLionel Sambuc 4976*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator, class _RandomAccessIterator> 4977*4684ddb6SLionel Sambuc_RandomAccessIterator 4978*4684ddb6SLionel Sambuc__partial_sort_copy(_InputIterator __first, _InputIterator __last, 4979*4684ddb6SLionel Sambuc _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 4980*4684ddb6SLionel Sambuc{ 4981*4684ddb6SLionel Sambuc _RandomAccessIterator __r = __result_first; 4982*4684ddb6SLionel Sambuc if (__r != __result_last) 4983*4684ddb6SLionel Sambuc { 4984*4684ddb6SLionel Sambuc typename iterator_traits<_RandomAccessIterator>::difference_type __len = 0; 4985*4684ddb6SLionel Sambuc for (; __first != __last && __r != __result_last; ++__first, ++__r, ++__len) 4986*4684ddb6SLionel Sambuc *__r = *__first; 4987*4684ddb6SLionel Sambuc __make_heap<_Compare>(__result_first, __r, __comp); 4988*4684ddb6SLionel Sambuc for (; __first != __last; ++__first) 4989*4684ddb6SLionel Sambuc if (__comp(*__first, *__result_first)) 4990*4684ddb6SLionel Sambuc { 4991*4684ddb6SLionel Sambuc *__result_first = *__first; 4992*4684ddb6SLionel Sambuc __push_heap_front<_Compare>(__result_first, __r, __comp, __len); 4993*4684ddb6SLionel Sambuc } 4994*4684ddb6SLionel Sambuc __sort_heap<_Compare>(__result_first, __r, __comp); 4995*4684ddb6SLionel Sambuc } 4996*4684ddb6SLionel Sambuc return __r; 4997*4684ddb6SLionel Sambuc} 4998*4684ddb6SLionel Sambuc 4999*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _RandomAccessIterator, class _Compare> 5000*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5001*4684ddb6SLionel Sambuc_RandomAccessIterator 5002*4684ddb6SLionel Sambucpartial_sort_copy(_InputIterator __first, _InputIterator __last, 5003*4684ddb6SLionel Sambuc _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) 5004*4684ddb6SLionel Sambuc{ 5005*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5006*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5007*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5008*4684ddb6SLionel Sambuc return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c); 5009*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5010*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5011*4684ddb6SLionel Sambuc return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp); 5012*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5013*4684ddb6SLionel Sambuc} 5014*4684ddb6SLionel Sambuc 5015*4684ddb6SLionel Sambuctemplate <class _InputIterator, class _RandomAccessIterator> 5016*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5017*4684ddb6SLionel Sambuc_RandomAccessIterator 5018*4684ddb6SLionel Sambucpartial_sort_copy(_InputIterator __first, _InputIterator __last, 5019*4684ddb6SLionel Sambuc _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) 5020*4684ddb6SLionel Sambuc{ 5021*4684ddb6SLionel Sambuc return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last, 5022*4684ddb6SLionel Sambuc __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 5023*4684ddb6SLionel Sambuc} 5024*4684ddb6SLionel Sambuc 5025*4684ddb6SLionel Sambuc// nth_element 5026*4684ddb6SLionel Sambuc 5027*4684ddb6SLionel Sambuctemplate <class _Compare, class _RandomAccessIterator> 5028*4684ddb6SLionel Sambucvoid 5029*4684ddb6SLionel Sambuc__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 5030*4684ddb6SLionel Sambuc{ 5031*4684ddb6SLionel Sambuc // _Compare is known to be a reference type 5032*4684ddb6SLionel Sambuc typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; 5033*4684ddb6SLionel Sambuc const difference_type __limit = 7; 5034*4684ddb6SLionel Sambuc while (true) 5035*4684ddb6SLionel Sambuc { 5036*4684ddb6SLionel Sambuc __restart: 5037*4684ddb6SLionel Sambuc if (__nth == __last) 5038*4684ddb6SLionel Sambuc return; 5039*4684ddb6SLionel Sambuc difference_type __len = __last - __first; 5040*4684ddb6SLionel Sambuc switch (__len) 5041*4684ddb6SLionel Sambuc { 5042*4684ddb6SLionel Sambuc case 0: 5043*4684ddb6SLionel Sambuc case 1: 5044*4684ddb6SLionel Sambuc return; 5045*4684ddb6SLionel Sambuc case 2: 5046*4684ddb6SLionel Sambuc if (__comp(*--__last, *__first)) 5047*4684ddb6SLionel Sambuc swap(*__first, *__last); 5048*4684ddb6SLionel Sambuc return; 5049*4684ddb6SLionel Sambuc case 3: 5050*4684ddb6SLionel Sambuc { 5051*4684ddb6SLionel Sambuc _RandomAccessIterator __m = __first; 5052*4684ddb6SLionel Sambuc _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp); 5053*4684ddb6SLionel Sambuc return; 5054*4684ddb6SLionel Sambuc } 5055*4684ddb6SLionel Sambuc } 5056*4684ddb6SLionel Sambuc if (__len <= __limit) 5057*4684ddb6SLionel Sambuc { 5058*4684ddb6SLionel Sambuc __selection_sort<_Compare>(__first, __last, __comp); 5059*4684ddb6SLionel Sambuc return; 5060*4684ddb6SLionel Sambuc } 5061*4684ddb6SLionel Sambuc // __len > __limit >= 3 5062*4684ddb6SLionel Sambuc _RandomAccessIterator __m = __first + __len/2; 5063*4684ddb6SLionel Sambuc _RandomAccessIterator __lm1 = __last; 5064*4684ddb6SLionel Sambuc unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp); 5065*4684ddb6SLionel Sambuc // *__m is median 5066*4684ddb6SLionel Sambuc // partition [__first, __m) < *__m and *__m <= [__m, __last) 5067*4684ddb6SLionel Sambuc // (this inhibits tossing elements equivalent to __m around unnecessarily) 5068*4684ddb6SLionel Sambuc _RandomAccessIterator __i = __first; 5069*4684ddb6SLionel Sambuc _RandomAccessIterator __j = __lm1; 5070*4684ddb6SLionel Sambuc // j points beyond range to be tested, *__lm1 is known to be <= *__m 5071*4684ddb6SLionel Sambuc // The search going up is known to be guarded but the search coming down isn't. 5072*4684ddb6SLionel Sambuc // Prime the downward search with a guard. 5073*4684ddb6SLionel Sambuc if (!__comp(*__i, *__m)) // if *__first == *__m 5074*4684ddb6SLionel Sambuc { 5075*4684ddb6SLionel Sambuc // *__first == *__m, *__first doesn't go in first part 5076*4684ddb6SLionel Sambuc // manually guard downward moving __j against __i 5077*4684ddb6SLionel Sambuc while (true) 5078*4684ddb6SLionel Sambuc { 5079*4684ddb6SLionel Sambuc if (__i == --__j) 5080*4684ddb6SLionel Sambuc { 5081*4684ddb6SLionel Sambuc // *__first == *__m, *__m <= all other elements 5082*4684ddb6SLionel Sambuc // Parition instead into [__first, __i) == *__first and *__first < [__i, __last) 5083*4684ddb6SLionel Sambuc ++__i; // __first + 1 5084*4684ddb6SLionel Sambuc __j = __last; 5085*4684ddb6SLionel Sambuc if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1) 5086*4684ddb6SLionel Sambuc { 5087*4684ddb6SLionel Sambuc while (true) 5088*4684ddb6SLionel Sambuc { 5089*4684ddb6SLionel Sambuc if (__i == __j) 5090*4684ddb6SLionel Sambuc return; // [__first, __last) all equivalent elements 5091*4684ddb6SLionel Sambuc if (__comp(*__first, *__i)) 5092*4684ddb6SLionel Sambuc { 5093*4684ddb6SLionel Sambuc swap(*__i, *__j); 5094*4684ddb6SLionel Sambuc ++__n_swaps; 5095*4684ddb6SLionel Sambuc ++__i; 5096*4684ddb6SLionel Sambuc break; 5097*4684ddb6SLionel Sambuc } 5098*4684ddb6SLionel Sambuc ++__i; 5099*4684ddb6SLionel Sambuc } 5100*4684ddb6SLionel Sambuc } 5101*4684ddb6SLionel Sambuc // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1 5102*4684ddb6SLionel Sambuc if (__i == __j) 5103*4684ddb6SLionel Sambuc return; 5104*4684ddb6SLionel Sambuc while (true) 5105*4684ddb6SLionel Sambuc { 5106*4684ddb6SLionel Sambuc while (!__comp(*__first, *__i)) 5107*4684ddb6SLionel Sambuc ++__i; 5108*4684ddb6SLionel Sambuc while (__comp(*__first, *--__j)) 5109*4684ddb6SLionel Sambuc ; 5110*4684ddb6SLionel Sambuc if (__i >= __j) 5111*4684ddb6SLionel Sambuc break; 5112*4684ddb6SLionel Sambuc swap(*__i, *__j); 5113*4684ddb6SLionel Sambuc ++__n_swaps; 5114*4684ddb6SLionel Sambuc ++__i; 5115*4684ddb6SLionel Sambuc } 5116*4684ddb6SLionel Sambuc // [__first, __i) == *__first and *__first < [__i, __last) 5117*4684ddb6SLionel Sambuc // The first part is sorted, 5118*4684ddb6SLionel Sambuc if (__nth < __i) 5119*4684ddb6SLionel Sambuc return; 5120*4684ddb6SLionel Sambuc // __nth_element the secod part 5121*4684ddb6SLionel Sambuc // __nth_element<_Compare>(__i, __nth, __last, __comp); 5122*4684ddb6SLionel Sambuc __first = __i; 5123*4684ddb6SLionel Sambuc goto __restart; 5124*4684ddb6SLionel Sambuc } 5125*4684ddb6SLionel Sambuc if (__comp(*__j, *__m)) 5126*4684ddb6SLionel Sambuc { 5127*4684ddb6SLionel Sambuc swap(*__i, *__j); 5128*4684ddb6SLionel Sambuc ++__n_swaps; 5129*4684ddb6SLionel Sambuc break; // found guard for downward moving __j, now use unguarded partition 5130*4684ddb6SLionel Sambuc } 5131*4684ddb6SLionel Sambuc } 5132*4684ddb6SLionel Sambuc } 5133*4684ddb6SLionel Sambuc ++__i; 5134*4684ddb6SLionel Sambuc // j points beyond range to be tested, *__lm1 is known to be <= *__m 5135*4684ddb6SLionel Sambuc // if not yet partitioned... 5136*4684ddb6SLionel Sambuc if (__i < __j) 5137*4684ddb6SLionel Sambuc { 5138*4684ddb6SLionel Sambuc // known that *(__i - 1) < *__m 5139*4684ddb6SLionel Sambuc while (true) 5140*4684ddb6SLionel Sambuc { 5141*4684ddb6SLionel Sambuc // __m still guards upward moving __i 5142*4684ddb6SLionel Sambuc while (__comp(*__i, *__m)) 5143*4684ddb6SLionel Sambuc ++__i; 5144*4684ddb6SLionel Sambuc // It is now known that a guard exists for downward moving __j 5145*4684ddb6SLionel Sambuc while (!__comp(*--__j, *__m)) 5146*4684ddb6SLionel Sambuc ; 5147*4684ddb6SLionel Sambuc if (__i >= __j) 5148*4684ddb6SLionel Sambuc break; 5149*4684ddb6SLionel Sambuc swap(*__i, *__j); 5150*4684ddb6SLionel Sambuc ++__n_swaps; 5151*4684ddb6SLionel Sambuc // It is known that __m != __j 5152*4684ddb6SLionel Sambuc // If __m just moved, follow it 5153*4684ddb6SLionel Sambuc if (__m == __i) 5154*4684ddb6SLionel Sambuc __m = __j; 5155*4684ddb6SLionel Sambuc ++__i; 5156*4684ddb6SLionel Sambuc } 5157*4684ddb6SLionel Sambuc } 5158*4684ddb6SLionel Sambuc // [__first, __i) < *__m and *__m <= [__i, __last) 5159*4684ddb6SLionel Sambuc if (__i != __m && __comp(*__m, *__i)) 5160*4684ddb6SLionel Sambuc { 5161*4684ddb6SLionel Sambuc swap(*__i, *__m); 5162*4684ddb6SLionel Sambuc ++__n_swaps; 5163*4684ddb6SLionel Sambuc } 5164*4684ddb6SLionel Sambuc // [__first, __i) < *__i and *__i <= [__i+1, __last) 5165*4684ddb6SLionel Sambuc if (__nth == __i) 5166*4684ddb6SLionel Sambuc return; 5167*4684ddb6SLionel Sambuc if (__n_swaps == 0) 5168*4684ddb6SLionel Sambuc { 5169*4684ddb6SLionel Sambuc // We were given a perfectly partitioned sequence. Coincidence? 5170*4684ddb6SLionel Sambuc if (__nth < __i) 5171*4684ddb6SLionel Sambuc { 5172*4684ddb6SLionel Sambuc // Check for [__first, __i) already sorted 5173*4684ddb6SLionel Sambuc __j = __m = __first; 5174*4684ddb6SLionel Sambuc while (++__j != __i) 5175*4684ddb6SLionel Sambuc { 5176*4684ddb6SLionel Sambuc if (__comp(*__j, *__m)) 5177*4684ddb6SLionel Sambuc // not yet sorted, so sort 5178*4684ddb6SLionel Sambuc goto not_sorted; 5179*4684ddb6SLionel Sambuc __m = __j; 5180*4684ddb6SLionel Sambuc } 5181*4684ddb6SLionel Sambuc // [__first, __i) sorted 5182*4684ddb6SLionel Sambuc return; 5183*4684ddb6SLionel Sambuc } 5184*4684ddb6SLionel Sambuc else 5185*4684ddb6SLionel Sambuc { 5186*4684ddb6SLionel Sambuc // Check for [__i, __last) already sorted 5187*4684ddb6SLionel Sambuc __j = __m = __i; 5188*4684ddb6SLionel Sambuc while (++__j != __last) 5189*4684ddb6SLionel Sambuc { 5190*4684ddb6SLionel Sambuc if (__comp(*__j, *__m)) 5191*4684ddb6SLionel Sambuc // not yet sorted, so sort 5192*4684ddb6SLionel Sambuc goto not_sorted; 5193*4684ddb6SLionel Sambuc __m = __j; 5194*4684ddb6SLionel Sambuc } 5195*4684ddb6SLionel Sambuc // [__i, __last) sorted 5196*4684ddb6SLionel Sambuc return; 5197*4684ddb6SLionel Sambuc } 5198*4684ddb6SLionel Sambuc } 5199*4684ddb6SLionel Sambucnot_sorted: 5200*4684ddb6SLionel Sambuc // __nth_element on range containing __nth 5201*4684ddb6SLionel Sambuc if (__nth < __i) 5202*4684ddb6SLionel Sambuc { 5203*4684ddb6SLionel Sambuc // __nth_element<_Compare>(__first, __nth, __i, __comp); 5204*4684ddb6SLionel Sambuc __last = __i; 5205*4684ddb6SLionel Sambuc } 5206*4684ddb6SLionel Sambuc else 5207*4684ddb6SLionel Sambuc { 5208*4684ddb6SLionel Sambuc // __nth_element<_Compare>(__i+1, __nth, __last, __comp); 5209*4684ddb6SLionel Sambuc __first = ++__i; 5210*4684ddb6SLionel Sambuc } 5211*4684ddb6SLionel Sambuc } 5212*4684ddb6SLionel Sambuc} 5213*4684ddb6SLionel Sambuc 5214*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator, class _Compare> 5215*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5216*4684ddb6SLionel Sambucvoid 5217*4684ddb6SLionel Sambucnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) 5218*4684ddb6SLionel Sambuc{ 5219*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5220*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5221*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5222*4684ddb6SLionel Sambuc __nth_element<_Comp_ref>(__first, __nth, __last, __c); 5223*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5224*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5225*4684ddb6SLionel Sambuc __nth_element<_Comp_ref>(__first, __nth, __last, __comp); 5226*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5227*4684ddb6SLionel Sambuc} 5228*4684ddb6SLionel Sambuc 5229*4684ddb6SLionel Sambuctemplate <class _RandomAccessIterator> 5230*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5231*4684ddb6SLionel Sambucvoid 5232*4684ddb6SLionel Sambucnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) 5233*4684ddb6SLionel Sambuc{ 5234*4684ddb6SLionel Sambuc _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>()); 5235*4684ddb6SLionel Sambuc} 5236*4684ddb6SLionel Sambuc 5237*4684ddb6SLionel Sambuc// includes 5238*4684ddb6SLionel Sambuc 5239*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2> 5240*4684ddb6SLionel Sambucbool 5241*4684ddb6SLionel Sambuc__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 5242*4684ddb6SLionel Sambuc _Compare __comp) 5243*4684ddb6SLionel Sambuc{ 5244*4684ddb6SLionel Sambuc for (; __first2 != __last2; ++__first1) 5245*4684ddb6SLionel Sambuc { 5246*4684ddb6SLionel Sambuc if (__first1 == __last1 || __comp(*__first2, *__first1)) 5247*4684ddb6SLionel Sambuc return false; 5248*4684ddb6SLionel Sambuc if (!__comp(*__first1, *__first2)) 5249*4684ddb6SLionel Sambuc ++__first2; 5250*4684ddb6SLionel Sambuc } 5251*4684ddb6SLionel Sambuc return true; 5252*4684ddb6SLionel Sambuc} 5253*4684ddb6SLionel Sambuc 5254*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _Compare> 5255*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5256*4684ddb6SLionel Sambucbool 5257*4684ddb6SLionel Sambucincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, 5258*4684ddb6SLionel Sambuc _Compare __comp) 5259*4684ddb6SLionel Sambuc{ 5260*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5261*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5262*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5263*4684ddb6SLionel Sambuc return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 5264*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5265*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5266*4684ddb6SLionel Sambuc return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 5267*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5268*4684ddb6SLionel Sambuc} 5269*4684ddb6SLionel Sambuc 5270*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2> 5271*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5272*4684ddb6SLionel Sambucbool 5273*4684ddb6SLionel Sambucincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) 5274*4684ddb6SLionel Sambuc{ 5275*4684ddb6SLionel Sambuc return _VSTD::includes(__first1, __last1, __first2, __last2, 5276*4684ddb6SLionel Sambuc __less<typename iterator_traits<_InputIterator1>::value_type, 5277*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::value_type>()); 5278*4684ddb6SLionel Sambuc} 5279*4684ddb6SLionel Sambuc 5280*4684ddb6SLionel Sambuc// set_union 5281*4684ddb6SLionel Sambuc 5282*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5283*4684ddb6SLionel Sambuc_OutputIterator 5284*4684ddb6SLionel Sambuc__set_union(_InputIterator1 __first1, _InputIterator1 __last1, 5285*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5286*4684ddb6SLionel Sambuc{ 5287*4684ddb6SLionel Sambuc for (; __first1 != __last1; ++__result) 5288*4684ddb6SLionel Sambuc { 5289*4684ddb6SLionel Sambuc if (__first2 == __last2) 5290*4684ddb6SLionel Sambuc return _VSTD::copy(__first1, __last1, __result); 5291*4684ddb6SLionel Sambuc if (__comp(*__first2, *__first1)) 5292*4684ddb6SLionel Sambuc { 5293*4684ddb6SLionel Sambuc *__result = *__first2; 5294*4684ddb6SLionel Sambuc ++__first2; 5295*4684ddb6SLionel Sambuc } 5296*4684ddb6SLionel Sambuc else 5297*4684ddb6SLionel Sambuc { 5298*4684ddb6SLionel Sambuc *__result = *__first1; 5299*4684ddb6SLionel Sambuc if (!__comp(*__first1, *__first2)) 5300*4684ddb6SLionel Sambuc ++__first2; 5301*4684ddb6SLionel Sambuc ++__first1; 5302*4684ddb6SLionel Sambuc } 5303*4684ddb6SLionel Sambuc } 5304*4684ddb6SLionel Sambuc return _VSTD::copy(__first2, __last2, __result); 5305*4684ddb6SLionel Sambuc} 5306*4684ddb6SLionel Sambuc 5307*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5308*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5309*4684ddb6SLionel Sambuc_OutputIterator 5310*4684ddb6SLionel Sambucset_union(_InputIterator1 __first1, _InputIterator1 __last1, 5311*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5312*4684ddb6SLionel Sambuc{ 5313*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5314*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5315*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5316*4684ddb6SLionel Sambuc return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5317*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5318*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5319*4684ddb6SLionel Sambuc return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5320*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5321*4684ddb6SLionel Sambuc} 5322*4684ddb6SLionel Sambuc 5323*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5324*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5325*4684ddb6SLionel Sambuc_OutputIterator 5326*4684ddb6SLionel Sambucset_union(_InputIterator1 __first1, _InputIterator1 __last1, 5327*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5328*4684ddb6SLionel Sambuc{ 5329*4684ddb6SLionel Sambuc return _VSTD::set_union(__first1, __last1, __first2, __last2, __result, 5330*4684ddb6SLionel Sambuc __less<typename iterator_traits<_InputIterator1>::value_type, 5331*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::value_type>()); 5332*4684ddb6SLionel Sambuc} 5333*4684ddb6SLionel Sambuc 5334*4684ddb6SLionel Sambuc// set_intersection 5335*4684ddb6SLionel Sambuc 5336*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5337*4684ddb6SLionel Sambuc_OutputIterator 5338*4684ddb6SLionel Sambuc__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 5339*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5340*4684ddb6SLionel Sambuc{ 5341*4684ddb6SLionel Sambuc while (__first1 != __last1 && __first2 != __last2) 5342*4684ddb6SLionel Sambuc { 5343*4684ddb6SLionel Sambuc if (__comp(*__first1, *__first2)) 5344*4684ddb6SLionel Sambuc ++__first1; 5345*4684ddb6SLionel Sambuc else 5346*4684ddb6SLionel Sambuc { 5347*4684ddb6SLionel Sambuc if (!__comp(*__first2, *__first1)) 5348*4684ddb6SLionel Sambuc { 5349*4684ddb6SLionel Sambuc *__result = *__first1; 5350*4684ddb6SLionel Sambuc ++__result; 5351*4684ddb6SLionel Sambuc ++__first1; 5352*4684ddb6SLionel Sambuc } 5353*4684ddb6SLionel Sambuc ++__first2; 5354*4684ddb6SLionel Sambuc } 5355*4684ddb6SLionel Sambuc } 5356*4684ddb6SLionel Sambuc return __result; 5357*4684ddb6SLionel Sambuc} 5358*4684ddb6SLionel Sambuc 5359*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5360*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5361*4684ddb6SLionel Sambuc_OutputIterator 5362*4684ddb6SLionel Sambucset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 5363*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5364*4684ddb6SLionel Sambuc{ 5365*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5366*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5367*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5368*4684ddb6SLionel Sambuc return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5369*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5370*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5371*4684ddb6SLionel Sambuc return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5372*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5373*4684ddb6SLionel Sambuc} 5374*4684ddb6SLionel Sambuc 5375*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5376*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5377*4684ddb6SLionel Sambuc_OutputIterator 5378*4684ddb6SLionel Sambucset_intersection(_InputIterator1 __first1, _InputIterator1 __last1, 5379*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5380*4684ddb6SLionel Sambuc{ 5381*4684ddb6SLionel Sambuc return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result, 5382*4684ddb6SLionel Sambuc __less<typename iterator_traits<_InputIterator1>::value_type, 5383*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::value_type>()); 5384*4684ddb6SLionel Sambuc} 5385*4684ddb6SLionel Sambuc 5386*4684ddb6SLionel Sambuc// set_difference 5387*4684ddb6SLionel Sambuc 5388*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5389*4684ddb6SLionel Sambuc_OutputIterator 5390*4684ddb6SLionel Sambuc__set_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5391*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5392*4684ddb6SLionel Sambuc{ 5393*4684ddb6SLionel Sambuc while (__first1 != __last1) 5394*4684ddb6SLionel Sambuc { 5395*4684ddb6SLionel Sambuc if (__first2 == __last2) 5396*4684ddb6SLionel Sambuc return _VSTD::copy(__first1, __last1, __result); 5397*4684ddb6SLionel Sambuc if (__comp(*__first1, *__first2)) 5398*4684ddb6SLionel Sambuc { 5399*4684ddb6SLionel Sambuc *__result = *__first1; 5400*4684ddb6SLionel Sambuc ++__result; 5401*4684ddb6SLionel Sambuc ++__first1; 5402*4684ddb6SLionel Sambuc } 5403*4684ddb6SLionel Sambuc else 5404*4684ddb6SLionel Sambuc { 5405*4684ddb6SLionel Sambuc if (!__comp(*__first2, *__first1)) 5406*4684ddb6SLionel Sambuc ++__first1; 5407*4684ddb6SLionel Sambuc ++__first2; 5408*4684ddb6SLionel Sambuc } 5409*4684ddb6SLionel Sambuc } 5410*4684ddb6SLionel Sambuc return __result; 5411*4684ddb6SLionel Sambuc} 5412*4684ddb6SLionel Sambuc 5413*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5414*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5415*4684ddb6SLionel Sambuc_OutputIterator 5416*4684ddb6SLionel Sambucset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5417*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5418*4684ddb6SLionel Sambuc{ 5419*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5420*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5421*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5422*4684ddb6SLionel Sambuc return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5423*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5424*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5425*4684ddb6SLionel Sambuc return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5426*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5427*4684ddb6SLionel Sambuc} 5428*4684ddb6SLionel Sambuc 5429*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5430*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5431*4684ddb6SLionel Sambuc_OutputIterator 5432*4684ddb6SLionel Sambucset_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5433*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5434*4684ddb6SLionel Sambuc{ 5435*4684ddb6SLionel Sambuc return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result, 5436*4684ddb6SLionel Sambuc __less<typename iterator_traits<_InputIterator1>::value_type, 5437*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::value_type>()); 5438*4684ddb6SLionel Sambuc} 5439*4684ddb6SLionel Sambuc 5440*4684ddb6SLionel Sambuc// set_symmetric_difference 5441*4684ddb6SLionel Sambuc 5442*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator> 5443*4684ddb6SLionel Sambuc_OutputIterator 5444*4684ddb6SLionel Sambuc__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5445*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5446*4684ddb6SLionel Sambuc{ 5447*4684ddb6SLionel Sambuc while (__first1 != __last1) 5448*4684ddb6SLionel Sambuc { 5449*4684ddb6SLionel Sambuc if (__first2 == __last2) 5450*4684ddb6SLionel Sambuc return _VSTD::copy(__first1, __last1, __result); 5451*4684ddb6SLionel Sambuc if (__comp(*__first1, *__first2)) 5452*4684ddb6SLionel Sambuc { 5453*4684ddb6SLionel Sambuc *__result = *__first1; 5454*4684ddb6SLionel Sambuc ++__result; 5455*4684ddb6SLionel Sambuc ++__first1; 5456*4684ddb6SLionel Sambuc } 5457*4684ddb6SLionel Sambuc else 5458*4684ddb6SLionel Sambuc { 5459*4684ddb6SLionel Sambuc if (__comp(*__first2, *__first1)) 5460*4684ddb6SLionel Sambuc { 5461*4684ddb6SLionel Sambuc *__result = *__first2; 5462*4684ddb6SLionel Sambuc ++__result; 5463*4684ddb6SLionel Sambuc } 5464*4684ddb6SLionel Sambuc else 5465*4684ddb6SLionel Sambuc ++__first1; 5466*4684ddb6SLionel Sambuc ++__first2; 5467*4684ddb6SLionel Sambuc } 5468*4684ddb6SLionel Sambuc } 5469*4684ddb6SLionel Sambuc return _VSTD::copy(__first2, __last2, __result); 5470*4684ddb6SLionel Sambuc} 5471*4684ddb6SLionel Sambuc 5472*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare> 5473*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5474*4684ddb6SLionel Sambuc_OutputIterator 5475*4684ddb6SLionel Sambucset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5476*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) 5477*4684ddb6SLionel Sambuc{ 5478*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5479*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5480*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5481*4684ddb6SLionel Sambuc return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); 5482*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5483*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5484*4684ddb6SLionel Sambuc return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); 5485*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5486*4684ddb6SLionel Sambuc} 5487*4684ddb6SLionel Sambuc 5488*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator> 5489*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5490*4684ddb6SLionel Sambuc_OutputIterator 5491*4684ddb6SLionel Sambucset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, 5492*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) 5493*4684ddb6SLionel Sambuc{ 5494*4684ddb6SLionel Sambuc return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, 5495*4684ddb6SLionel Sambuc __less<typename iterator_traits<_InputIterator1>::value_type, 5496*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::value_type>()); 5497*4684ddb6SLionel Sambuc} 5498*4684ddb6SLionel Sambuc 5499*4684ddb6SLionel Sambuc// lexicographical_compare 5500*4684ddb6SLionel Sambuc 5501*4684ddb6SLionel Sambuctemplate <class _Compare, class _InputIterator1, class _InputIterator2> 5502*4684ddb6SLionel Sambucbool 5503*4684ddb6SLionel Sambuc__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 5504*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 5505*4684ddb6SLionel Sambuc{ 5506*4684ddb6SLionel Sambuc for (; __first2 != __last2; ++__first1, ++__first2) 5507*4684ddb6SLionel Sambuc { 5508*4684ddb6SLionel Sambuc if (__first1 == __last1 || __comp(*__first1, *__first2)) 5509*4684ddb6SLionel Sambuc return true; 5510*4684ddb6SLionel Sambuc if (__comp(*__first2, *__first1)) 5511*4684ddb6SLionel Sambuc return false; 5512*4684ddb6SLionel Sambuc } 5513*4684ddb6SLionel Sambuc return false; 5514*4684ddb6SLionel Sambuc} 5515*4684ddb6SLionel Sambuc 5516*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2, class _Compare> 5517*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5518*4684ddb6SLionel Sambucbool 5519*4684ddb6SLionel Sambuclexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 5520*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) 5521*4684ddb6SLionel Sambuc{ 5522*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5523*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5524*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5525*4684ddb6SLionel Sambuc return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c); 5526*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5527*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5528*4684ddb6SLionel Sambuc return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp); 5529*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5530*4684ddb6SLionel Sambuc} 5531*4684ddb6SLionel Sambuc 5532*4684ddb6SLionel Sambuctemplate <class _InputIterator1, class _InputIterator2> 5533*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5534*4684ddb6SLionel Sambucbool 5535*4684ddb6SLionel Sambuclexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, 5536*4684ddb6SLionel Sambuc _InputIterator2 __first2, _InputIterator2 __last2) 5537*4684ddb6SLionel Sambuc{ 5538*4684ddb6SLionel Sambuc return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2, 5539*4684ddb6SLionel Sambuc __less<typename iterator_traits<_InputIterator1>::value_type, 5540*4684ddb6SLionel Sambuc typename iterator_traits<_InputIterator2>::value_type>()); 5541*4684ddb6SLionel Sambuc} 5542*4684ddb6SLionel Sambuc 5543*4684ddb6SLionel Sambuc// next_permutation 5544*4684ddb6SLionel Sambuc 5545*4684ddb6SLionel Sambuctemplate <class _Compare, class _BidirectionalIterator> 5546*4684ddb6SLionel Sambucbool 5547*4684ddb6SLionel Sambuc__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5548*4684ddb6SLionel Sambuc{ 5549*4684ddb6SLionel Sambuc _BidirectionalIterator __i = __last; 5550*4684ddb6SLionel Sambuc if (__first == __last || __first == --__i) 5551*4684ddb6SLionel Sambuc return false; 5552*4684ddb6SLionel Sambuc while (true) 5553*4684ddb6SLionel Sambuc { 5554*4684ddb6SLionel Sambuc _BidirectionalIterator __ip1 = __i; 5555*4684ddb6SLionel Sambuc if (__comp(*--__i, *__ip1)) 5556*4684ddb6SLionel Sambuc { 5557*4684ddb6SLionel Sambuc _BidirectionalIterator __j = __last; 5558*4684ddb6SLionel Sambuc while (!__comp(*__i, *--__j)) 5559*4684ddb6SLionel Sambuc ; 5560*4684ddb6SLionel Sambuc swap(*__i, *__j); 5561*4684ddb6SLionel Sambuc _VSTD::reverse(__ip1, __last); 5562*4684ddb6SLionel Sambuc return true; 5563*4684ddb6SLionel Sambuc } 5564*4684ddb6SLionel Sambuc if (__i == __first) 5565*4684ddb6SLionel Sambuc { 5566*4684ddb6SLionel Sambuc _VSTD::reverse(__first, __last); 5567*4684ddb6SLionel Sambuc return false; 5568*4684ddb6SLionel Sambuc } 5569*4684ddb6SLionel Sambuc } 5570*4684ddb6SLionel Sambuc} 5571*4684ddb6SLionel Sambuc 5572*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator, class _Compare> 5573*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5574*4684ddb6SLionel Sambucbool 5575*4684ddb6SLionel Sambucnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5576*4684ddb6SLionel Sambuc{ 5577*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5578*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5579*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5580*4684ddb6SLionel Sambuc return __next_permutation<_Comp_ref>(__first, __last, __c); 5581*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5582*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5583*4684ddb6SLionel Sambuc return __next_permutation<_Comp_ref>(__first, __last, __comp); 5584*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5585*4684ddb6SLionel Sambuc} 5586*4684ddb6SLionel Sambuc 5587*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 5588*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5589*4684ddb6SLionel Sambucbool 5590*4684ddb6SLionel Sambucnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 5591*4684ddb6SLionel Sambuc{ 5592*4684ddb6SLionel Sambuc return _VSTD::next_permutation(__first, __last, 5593*4684ddb6SLionel Sambuc __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 5594*4684ddb6SLionel Sambuc} 5595*4684ddb6SLionel Sambuc 5596*4684ddb6SLionel Sambuc// prev_permutation 5597*4684ddb6SLionel Sambuc 5598*4684ddb6SLionel Sambuctemplate <class _Compare, class _BidirectionalIterator> 5599*4684ddb6SLionel Sambucbool 5600*4684ddb6SLionel Sambuc__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5601*4684ddb6SLionel Sambuc{ 5602*4684ddb6SLionel Sambuc _BidirectionalIterator __i = __last; 5603*4684ddb6SLionel Sambuc if (__first == __last || __first == --__i) 5604*4684ddb6SLionel Sambuc return false; 5605*4684ddb6SLionel Sambuc while (true) 5606*4684ddb6SLionel Sambuc { 5607*4684ddb6SLionel Sambuc _BidirectionalIterator __ip1 = __i; 5608*4684ddb6SLionel Sambuc if (__comp(*__ip1, *--__i)) 5609*4684ddb6SLionel Sambuc { 5610*4684ddb6SLionel Sambuc _BidirectionalIterator __j = __last; 5611*4684ddb6SLionel Sambuc while (!__comp(*--__j, *__i)) 5612*4684ddb6SLionel Sambuc ; 5613*4684ddb6SLionel Sambuc swap(*__i, *__j); 5614*4684ddb6SLionel Sambuc _VSTD::reverse(__ip1, __last); 5615*4684ddb6SLionel Sambuc return true; 5616*4684ddb6SLionel Sambuc } 5617*4684ddb6SLionel Sambuc if (__i == __first) 5618*4684ddb6SLionel Sambuc { 5619*4684ddb6SLionel Sambuc _VSTD::reverse(__first, __last); 5620*4684ddb6SLionel Sambuc return false; 5621*4684ddb6SLionel Sambuc } 5622*4684ddb6SLionel Sambuc } 5623*4684ddb6SLionel Sambuc} 5624*4684ddb6SLionel Sambuc 5625*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator, class _Compare> 5626*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5627*4684ddb6SLionel Sambucbool 5628*4684ddb6SLionel Sambucprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) 5629*4684ddb6SLionel Sambuc{ 5630*4684ddb6SLionel Sambuc#ifdef _LIBCPP_DEBUG 5631*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; 5632*4684ddb6SLionel Sambuc __debug_less<_Compare> __c(__comp); 5633*4684ddb6SLionel Sambuc return __prev_permutation<_Comp_ref>(__first, __last, __c); 5634*4684ddb6SLionel Sambuc#else // _LIBCPP_DEBUG 5635*4684ddb6SLionel Sambuc typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; 5636*4684ddb6SLionel Sambuc return __prev_permutation<_Comp_ref>(__first, __last, __comp); 5637*4684ddb6SLionel Sambuc#endif // _LIBCPP_DEBUG 5638*4684ddb6SLionel Sambuc} 5639*4684ddb6SLionel Sambuc 5640*4684ddb6SLionel Sambuctemplate <class _BidirectionalIterator> 5641*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5642*4684ddb6SLionel Sambucbool 5643*4684ddb6SLionel Sambucprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) 5644*4684ddb6SLionel Sambuc{ 5645*4684ddb6SLionel Sambuc return _VSTD::prev_permutation(__first, __last, 5646*4684ddb6SLionel Sambuc __less<typename iterator_traits<_BidirectionalIterator>::value_type>()); 5647*4684ddb6SLionel Sambuc} 5648*4684ddb6SLionel Sambuc 5649*4684ddb6SLionel Sambuctemplate <class _Tp> 5650*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5651*4684ddb6SLionel Sambuctypename enable_if 5652*4684ddb6SLionel Sambuc< 5653*4684ddb6SLionel Sambuc is_integral<_Tp>::value, 5654*4684ddb6SLionel Sambuc _Tp 5655*4684ddb6SLionel Sambuc>::type 5656*4684ddb6SLionel Sambuc__rotate_left(_Tp __t, _Tp __n = 1) 5657*4684ddb6SLionel Sambuc{ 5658*4684ddb6SLionel Sambuc const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1); 5659*4684ddb6SLionel Sambuc __n &= __bits; 5660*4684ddb6SLionel Sambuc return static_cast<_Tp>((__t << __n) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> (__bits - __n))); 5661*4684ddb6SLionel Sambuc} 5662*4684ddb6SLionel Sambuc 5663*4684ddb6SLionel Sambuctemplate <class _Tp> 5664*4684ddb6SLionel Sambucinline _LIBCPP_INLINE_VISIBILITY 5665*4684ddb6SLionel Sambuctypename enable_if 5666*4684ddb6SLionel Sambuc< 5667*4684ddb6SLionel Sambuc is_integral<_Tp>::value, 5668*4684ddb6SLionel Sambuc _Tp 5669*4684ddb6SLionel Sambuc>::type 5670*4684ddb6SLionel Sambuc__rotate_right(_Tp __t, _Tp __n = 1) 5671*4684ddb6SLionel Sambuc{ 5672*4684ddb6SLionel Sambuc const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1); 5673*4684ddb6SLionel Sambuc __n &= __bits; 5674*4684ddb6SLionel Sambuc return static_cast<_Tp>((__t << (__bits - __n)) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> __n)); 5675*4684ddb6SLionel Sambuc} 5676*4684ddb6SLionel Sambuc 5677*4684ddb6SLionel Sambuc_LIBCPP_END_NAMESPACE_STD 5678*4684ddb6SLionel Sambuc 5679*4684ddb6SLionel Sambuc#endif // _LIBCPP_ALGORITHM 5680