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