1*0b57cec5SDimitry Andric// -*- C++ -*- 2349cc55cSDimitry Andric//===----------------------------------------------------------------------===// 3*0b57cec5SDimitry Andric// 4*0b57cec5SDimitry Andric// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5*0b57cec5SDimitry Andric// See https://llvm.org/LICENSE.txt for license information. 6*0b57cec5SDimitry Andric// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7*0b57cec5SDimitry Andric// 8*0b57cec5SDimitry Andric//===----------------------------------------------------------------------===// 9*0b57cec5SDimitry Andric 10*0b57cec5SDimitry Andric#ifndef _LIBCPP_ALGORITHM 11*0b57cec5SDimitry Andric#define _LIBCPP_ALGORITHM 12*0b57cec5SDimitry Andric 13*0b57cec5SDimitry Andric/* 14*0b57cec5SDimitry Andric algorithm synopsis 15*0b57cec5SDimitry Andric 16*0b57cec5SDimitry Andric#include <initializer_list> 17*0b57cec5SDimitry Andric 18*0b57cec5SDimitry Andricnamespace std 19*0b57cec5SDimitry Andric{ 20*0b57cec5SDimitry Andric 2104eeddc0SDimitry Andricnamespace ranges { 2281ad6265SDimitry Andric 2381ad6265SDimitry Andric // [algorithms.results], algorithm result types 2481ad6265SDimitry Andric template <class I, class F> 2581ad6265SDimitry Andric struct in_fun_result; // since C++20 2681ad6265SDimitry Andric 2704eeddc0SDimitry Andric template <class I1, class I2> 2804eeddc0SDimitry Andric struct in_in_result; // since C++20 291fd87a68SDimitry Andric 3081ad6265SDimitry Andric template <class I, class O> 3181ad6265SDimitry Andric struct in_out_result; // since C++20 3281ad6265SDimitry Andric 331fd87a68SDimitry Andric template <class I1, class I2, class O> 341fd87a68SDimitry Andric struct in_in_out_result; // since C++20 3581ad6265SDimitry Andric 3681ad6265SDimitry Andric template <class I, class O1, class O2> 3781ad6265SDimitry Andric struct in_out_out_result; // since C++20 3881ad6265SDimitry Andric 3981ad6265SDimitry Andric template <class I1, class I2> 4081ad6265SDimitry Andric struct min_max_result; // since C++20 4181ad6265SDimitry Andric 4281ad6265SDimitry Andric template <class I> 4381ad6265SDimitry Andric struct in_found_result; // since C++20 4481ad6265SDimitry Andric 4581ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 4681ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> // since C++20 4781ad6265SDimitry Andric constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {}); 4881ad6265SDimitry Andric 4981ad6265SDimitry Andric template<forward_range R, class Proj = identity, 5081ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20 5181ad6265SDimitry Andric constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {}); 5281ad6265SDimitry Andric 5381ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 5481ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> 5581ad6265SDimitry Andric constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 5681ad6265SDimitry Andric 5781ad6265SDimitry Andric template<forward_range R, class Proj = identity, 5881ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 5981ad6265SDimitry Andric constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 6081ad6265SDimitry Andric 6181ad6265SDimitry Andric template<class I1, class I2> 6281ad6265SDimitry Andric using mismatch_result = in_in_result<I1, I2>; 6381ad6265SDimitry Andric 6481ad6265SDimitry Andric template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2, 6581ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 6681ad6265SDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 6781ad6265SDimitry Andric constexpr mismatch_result<_I1, _I2> 6881ad6265SDimitry Andric mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20 6981ad6265SDimitry Andric 7081ad6265SDimitry Andric template <input_range R1, input_range R2, 7181ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 7281ad6265SDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 7381ad6265SDimitry Andric constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> 7481ad6265SDimitry Andric mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20 7581ad6265SDimitry Andric 7681ad6265SDimitry Andric requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*> 7781ad6265SDimitry Andric constexpr I find(I first, S last, const T& value, Proj proj = {}); // since C++20 7881ad6265SDimitry Andric 7981ad6265SDimitry Andric template<input_range R, class T, class Proj = identity> 8081ad6265SDimitry Andric requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> 8181ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 8281ad6265SDimitry Andric find(R&& r, const T& value, Proj proj = {}); // since C++20 8381ad6265SDimitry Andric 8481ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 8581ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 8681ad6265SDimitry Andric constexpr I find_if(I first, S last, Pred pred, Proj proj = {}); // since C++20 8781ad6265SDimitry Andric 8881ad6265SDimitry Andric template<input_range R, class Proj = identity, 8981ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 9081ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 9181ad6265SDimitry Andric find_if(R&& r, Pred pred, Proj proj = {}); // since C++20 9281ad6265SDimitry Andric 9381ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 9481ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 9581ad6265SDimitry Andric constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {}); // since C++20 9681ad6265SDimitry Andric 9781ad6265SDimitry Andric template<input_range R, class Proj = identity, 9881ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 9981ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 10081ad6265SDimitry Andric find_if_not(R&& r, Pred pred, Proj proj = {}); // since C++20 10181ad6265SDimitry Andric 10281ad6265SDimitry Andric template<class T, class Proj = identity, 10381ad6265SDimitry Andric indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less> 10481ad6265SDimitry Andric constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20 10581ad6265SDimitry Andric 10681ad6265SDimitry Andric template<copyable T, class Proj = identity, 10781ad6265SDimitry Andric indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less> 10881ad6265SDimitry Andric constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20 10981ad6265SDimitry Andric 11081ad6265SDimitry Andric template<input_range R, class Proj = identity, 11181ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 11281ad6265SDimitry Andric requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*> 11381ad6265SDimitry Andric constexpr range_value_t<R> 11481ad6265SDimitry Andric min(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 11581ad6265SDimitry Andric 11681ad6265SDimitry Andric template<class T, class Proj = identity, 11781ad6265SDimitry Andric indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less> 11881ad6265SDimitry Andric constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20 11981ad6265SDimitry Andric 12081ad6265SDimitry Andric template<copyable T, class Proj = identity, 12181ad6265SDimitry Andric indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less> 12281ad6265SDimitry Andric constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20 12381ad6265SDimitry Andric 12481ad6265SDimitry Andric template<input_range R, class Proj = identity, 12581ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 12681ad6265SDimitry Andric requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*> 12781ad6265SDimitry Andric constexpr range_value_t<R> 12881ad6265SDimitry Andric max(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 12981ad6265SDimitry Andric 13081ad6265SDimitry Andric template<class I, class O> 13181ad6265SDimitry Andric using unary_transform_result = in_out_result<I, O>; // since C++20 13281ad6265SDimitry Andric 13381ad6265SDimitry Andric template<class I1, class I2, class O> 13481ad6265SDimitry Andric using binary_transform_result = in_in_out_result<I1, I2, O>; // since C++20 13581ad6265SDimitry Andric 13681ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, 13781ad6265SDimitry Andric copy_constructible F, class Proj = identity> 13881ad6265SDimitry Andric requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>> 13981ad6265SDimitry Andric constexpr ranges::unary_transform_result<I, O> 14081ad6265SDimitry Andric transform(I first1, S last1, O result, F op, Proj proj = {}); // since C++20 14181ad6265SDimitry Andric 14281ad6265SDimitry Andric template<input_range R, weakly_incrementable O, copy_constructible F, 14381ad6265SDimitry Andric class Proj = identity> 14481ad6265SDimitry Andric requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>> 14581ad6265SDimitry Andric constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O> 14681ad6265SDimitry Andric transform(R&& r, O result, F op, Proj proj = {}); // since C++20 14781ad6265SDimitry Andric 14881ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 14981ad6265SDimitry Andric weakly_incrementable O, copy_constructible F, class Proj1 = identity, 15081ad6265SDimitry Andric class Proj2 = identity> 15181ad6265SDimitry Andric requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>, 15281ad6265SDimitry Andric projected<I2, Proj2>>> 15381ad6265SDimitry Andric constexpr ranges::binary_transform_result<I1, I2, O> 15481ad6265SDimitry Andric transform(I1 first1, S1 last1, I2 first2, S2 last2, O result, 15581ad6265SDimitry Andric F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 15681ad6265SDimitry Andric 15781ad6265SDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, 15881ad6265SDimitry Andric copy_constructible F, class Proj1 = identity, class Proj2 = identity> 15981ad6265SDimitry Andric requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>, 16081ad6265SDimitry Andric projected<iterator_t<R2>, Proj2>>> 16181ad6265SDimitry Andric constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> 16281ad6265SDimitry Andric transform(R1&& r1, R2&& r2, O result, 16381ad6265SDimitry Andric F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 16481ad6265SDimitry Andric 16581ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity> 16681ad6265SDimitry Andric requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*> 16781ad6265SDimitry Andric constexpr iter_difference_t<I> 16881ad6265SDimitry Andric count(I first, S last, const T& value, Proj proj = {}); // since C++20 16981ad6265SDimitry Andric 17081ad6265SDimitry Andric template<input_range R, class T, class Proj = identity> 17181ad6265SDimitry Andric requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> 17281ad6265SDimitry Andric constexpr range_difference_t<R> 17381ad6265SDimitry Andric count(R&& r, const T& value, Proj proj = {}); // since C++20 17481ad6265SDimitry Andric 17581ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 17681ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 17781ad6265SDimitry Andric constexpr iter_difference_t<I> 17881ad6265SDimitry Andric count_if(I first, S last, Pred pred, Proj proj = {}); // since C++20 17981ad6265SDimitry Andric 18081ad6265SDimitry Andric template<input_range R, class Proj = identity, 18181ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 18281ad6265SDimitry Andric constexpr range_difference_t<R> 18381ad6265SDimitry Andric count_if(R&& r, Pred pred, Proj proj = {}); // since C++20 18481ad6265SDimitry Andric 18581ad6265SDimitry Andric template<class T> 18681ad6265SDimitry Andric using minmax_result = min_max_result<T>; 18781ad6265SDimitry Andric 18881ad6265SDimitry Andric template<class T, class Proj = identity, 18981ad6265SDimitry Andric indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less> 19081ad6265SDimitry Andric constexpr ranges::minmax_result<const T&> 19181ad6265SDimitry Andric minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20 19281ad6265SDimitry Andric 19381ad6265SDimitry Andric template<copyable T, class Proj = identity, 19481ad6265SDimitry Andric indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less> 19581ad6265SDimitry Andric constexpr ranges::minmax_result<T> 19681ad6265SDimitry Andric minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {}); // since C++20 19781ad6265SDimitry Andric 19881ad6265SDimitry Andric template<input_range R, class Proj = identity, 19981ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 20081ad6265SDimitry Andric requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*> 20181ad6265SDimitry Andric constexpr ranges::minmax_result<range_value_t<R>> 20281ad6265SDimitry Andric minmax(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 20381ad6265SDimitry Andric 20481ad6265SDimitry Andric template<class I> 20581ad6265SDimitry Andric using minmax_element_result = min_max_result<I>; 20681ad6265SDimitry Andric 20781ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 20881ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> 20981ad6265SDimitry Andric constexpr ranges::minmax_element_result<I> 21081ad6265SDimitry Andric minmax_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 21181ad6265SDimitry Andric 21281ad6265SDimitry Andric template<forward_range R, class Proj = identity, 21381ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 21481ad6265SDimitry Andric constexpr ranges::minmax_element_result<borrowed_iterator_t<R>> 21581ad6265SDimitry Andric minmax_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 21681ad6265SDimitry Andric 21781ad6265SDimitry Andric template<class I, class O> 21881ad6265SDimitry Andric using copy_result = in_out_result<I, O>; // since C++20 21981ad6265SDimitry Andric 22081ad6265SDimitry Andric template<class I, class O> 22181ad6265SDimitry Andric using copy_n_result = in_out_result<I, O>; // since C++20 22281ad6265SDimitry Andric 22381ad6265SDimitry Andric template<class I, class O> 22481ad6265SDimitry Andric using copy_if_result = in_out_result<I, O>; // since C++20 22581ad6265SDimitry Andric 22681ad6265SDimitry Andric template<class I1, class I2> 22781ad6265SDimitry Andric using copy_backward_result = in_out_result<I1, I2>; // since C++20 22881ad6265SDimitry Andric 22981ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, weakly_incrementable O> 23081ad6265SDimitry Andric requires indirectly_copyable<I, O> 23181ad6265SDimitry Andric constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result); // since C++20 23281ad6265SDimitry Andric 23381ad6265SDimitry Andric template<input_range R, weakly_incrementable O> 23481ad6265SDimitry Andric requires indirectly_copyable<iterator_t<R>, O> 23581ad6265SDimitry Andric constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result); // since C++20 23681ad6265SDimitry Andric 23781ad6265SDimitry Andric template<input_iterator I, weakly_incrementable O> 23881ad6265SDimitry Andric requires indirectly_copyable<I, O> 23981ad6265SDimitry Andric constexpr ranges::copy_n_result<I, O> 24081ad6265SDimitry Andric ranges::copy_n(I first, iter_difference_t<I> n, O result); // since C++20 24181ad6265SDimitry Andric 24281ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity, 24381ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 24481ad6265SDimitry Andric requires indirectly_copyable<I, O> 24581ad6265SDimitry Andric constexpr ranges::copy_if_result<I, O> 24681ad6265SDimitry Andric ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {}); // since C++20 24781ad6265SDimitry Andric 24881ad6265SDimitry Andric template<input_range R, weakly_incrementable O, class Proj = identity, 24981ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 25081ad6265SDimitry Andric requires indirectly_copyable<iterator_t<R>, O> 25181ad6265SDimitry Andric constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O> 25281ad6265SDimitry Andric ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {}); // since C++20 25381ad6265SDimitry Andric 25481ad6265SDimitry Andric template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2> 25581ad6265SDimitry Andric requires indirectly_copyable<I1, I2> 25681ad6265SDimitry Andric constexpr ranges::copy_backward_result<I1, I2> 25781ad6265SDimitry Andric ranges::copy_backward(I1 first, S1 last, I2 result); // since C++20 25881ad6265SDimitry Andric 25981ad6265SDimitry Andric template<bidirectional_range R, bidirectional_iterator I> 26081ad6265SDimitry Andric requires indirectly_copyable<iterator_t<R>, I> 26181ad6265SDimitry Andric constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I> 26281ad6265SDimitry Andric ranges::copy_backward(R&& r, I result); // since C++20 26381ad6265SDimitry Andric 26481ad6265SDimitry Andric template<class I, class F> 26581ad6265SDimitry Andric using for_each_result = in_fun_result<I, F>; // since C++20 26681ad6265SDimitry Andric 26781ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 26881ad6265SDimitry Andric indirectly_unary_invocable<projected<I, Proj>> Fun> 26981ad6265SDimitry Andric constexpr ranges::for_each_result<I, Fun> 27081ad6265SDimitry Andric ranges::for_each(I first, S last, Fun f, Proj proj = {}); // since C++20 27181ad6265SDimitry Andric 27281ad6265SDimitry Andric template<input_range R, class Proj = identity, 27381ad6265SDimitry Andric indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun> 27481ad6265SDimitry Andric constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun> 27581ad6265SDimitry Andric ranges::for_each(R&& r, Fun f, Proj proj = {}); // since C++20 27681ad6265SDimitry Andric 27781ad6265SDimitry Andric template<input_iterator I, class Proj = identity, 27881ad6265SDimitry Andric indirectly_unary_invocable<projected<I, Proj>> Fun> 27981ad6265SDimitry Andric constexpr ranges::for_each_n_result<I, Fun> 28081ad6265SDimitry Andric ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {}); // since C++20 28181ad6265SDimitry Andric 28281ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 28381ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 28481ad6265SDimitry Andric constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {}); // since C++20 28581ad6265SDimitry Andric 28681ad6265SDimitry Andric template<input_range R, class Proj = identity, 28781ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 28881ad6265SDimitry Andric constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {}); // since C++20 28981ad6265SDimitry Andric 290753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 291753f127fSDimitry Andric class Proj = identity> 292753f127fSDimitry Andric requires sortable<I, Comp, Proj> 293753f127fSDimitry Andric constexpr I 294753f127fSDimitry Andric ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 295753f127fSDimitry Andric 296753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 297753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 298753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 299753f127fSDimitry Andric ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 300753f127fSDimitry Andric 301753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 302753f127fSDimitry Andric class Proj = identity> 303753f127fSDimitry Andric requires sortable<I, Comp, Proj> 304753f127fSDimitry Andric constexpr I 305753f127fSDimitry Andric ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 306753f127fSDimitry Andric 307753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 308753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 309753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 310753f127fSDimitry Andric ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 311753f127fSDimitry Andric 312753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 313753f127fSDimitry Andric class Proj = identity> 314753f127fSDimitry Andric requires sortable<I, Comp, Proj> 315753f127fSDimitry Andric constexpr I 316753f127fSDimitry Andric ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 317753f127fSDimitry Andric 318753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 319753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 320753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 321753f127fSDimitry Andric ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 322753f127fSDimitry Andric 323753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 324753f127fSDimitry Andric class Proj = identity> 325753f127fSDimitry Andric requires sortable<I, Comp, Proj> 326753f127fSDimitry Andric constexpr I 327753f127fSDimitry Andric ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 328753f127fSDimitry Andric 329753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 330753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 331753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 332753f127fSDimitry Andric ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 333753f127fSDimitry Andric 33481ad6265SDimitry Andric template<bidirectional_iterator I, sentinel_for<I> S> 33581ad6265SDimitry Andric requires permutable<I> 33681ad6265SDimitry Andric constexpr I ranges::reverse(I first, S last); // since C++20 33781ad6265SDimitry Andric 33881ad6265SDimitry Andric template<bidirectional_range R> 33981ad6265SDimitry Andric requires permutable<iterator_t<R>> 34081ad6265SDimitry Andric constexpr borrowed_iterator_t<R> ranges::reverse(R&& r); // since C++20 34181ad6265SDimitry Andric 34281ad6265SDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 34381ad6265SDimitry Andric class Proj = identity> 34481ad6265SDimitry Andric requires sortable<I, Comp, Proj> 34581ad6265SDimitry Andric constexpr I 34681ad6265SDimitry Andric ranges::sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 34781ad6265SDimitry Andric 34881ad6265SDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 34981ad6265SDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 35081ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 35181ad6265SDimitry Andric ranges::sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 35281ad6265SDimitry Andric 35381ad6265SDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 35481ad6265SDimitry Andric class Proj = identity> 35581ad6265SDimitry Andric requires sortable<I, Comp, Proj> 35681ad6265SDimitry Andric I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 35781ad6265SDimitry Andric 35881ad6265SDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 35981ad6265SDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 36081ad6265SDimitry Andric borrowed_iterator_t<R> 36181ad6265SDimitry Andric ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 36281ad6265SDimitry Andric 363fcaf7f86SDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 364fcaf7f86SDimitry Andric class Proj = identity> 365fcaf7f86SDimitry Andric requires sortable<I, Comp, Proj> 366fcaf7f86SDimitry Andric constexpr I 367fcaf7f86SDimitry Andric ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {}); // since C++20 368fcaf7f86SDimitry Andric 369fcaf7f86SDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 370fcaf7f86SDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 371fcaf7f86SDimitry Andric constexpr borrowed_iterator_t<R> 372fcaf7f86SDimitry Andric ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {}); // since C++20 373fcaf7f86SDimitry Andric 37481ad6265SDimitry Andric template<class T, output_iterator<const T&> O, sentinel_for<O> S> 37581ad6265SDimitry Andric constexpr O ranges::fill(O first, S last, const T& value); // since C++20 37681ad6265SDimitry Andric 37781ad6265SDimitry Andric template<class T, output_range<const T&> R> 37881ad6265SDimitry Andric constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value); // since C++20 37981ad6265SDimitry Andric 38081ad6265SDimitry Andric template<class T, output_iterator<const T&> O> 38181ad6265SDimitry Andric constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value); // since C++20 38281ad6265SDimitry Andric 38381ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 38481ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 38581ad6265SDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 38681ad6265SDimitry Andric constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2, 38781ad6265SDimitry Andric Pred pred = {}, 38881ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 38981ad6265SDimitry Andric 39081ad6265SDimitry Andric template<input_range R1, input_range R2, class Pred = ranges::equal_to, 39181ad6265SDimitry Andric class Proj1 = identity, class Proj2 = identity> 39281ad6265SDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 39381ad6265SDimitry Andric constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {}, 39481ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 39581ad6265SDimitry Andric 39681ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 39781ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 39881ad6265SDimitry Andric constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {}); // since C++20 39981ad6265SDimitry Andric 40081ad6265SDimitry Andric template<input_range R, class Proj = identity, 40181ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 40281ad6265SDimitry Andric constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {}); // since C++20 40381ad6265SDimitry Andric 40481ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 40581ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 40681ad6265SDimitry Andric constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {}); // since C++20 40781ad6265SDimitry Andric 40881ad6265SDimitry Andric template<input_range R, class Proj = identity, 40981ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 41081ad6265SDimitry Andric constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {}); // since C++20 41181ad6265SDimitry Andric 41281ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 41381ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 41481ad6265SDimitry Andric constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {}); // since C++20 41581ad6265SDimitry Andric 41681ad6265SDimitry Andric template<input_range R, class Proj = identity, 41781ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 41881ad6265SDimitry Andric constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {}); // since C++20 41981ad6265SDimitry Andric 42081ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 42181ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> 42281ad6265SDimitry Andric constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 42381ad6265SDimitry Andric 42481ad6265SDimitry Andric template<forward_range R, class Proj = identity, 42581ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 42681ad6265SDimitry Andric constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 42781ad6265SDimitry Andric 42881ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 42981ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> 43081ad6265SDimitry Andric constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 43181ad6265SDimitry Andric 43281ad6265SDimitry Andric template<forward_range R, class Proj = identity, 43381ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 43481ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 43581ad6265SDimitry Andric ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 43681ad6265SDimitry Andric 437753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 438753f127fSDimitry Andric class Proj = identity> 439753f127fSDimitry Andric requires sortable<I, Comp, Proj> 440753f127fSDimitry Andric constexpr I 441753f127fSDimitry Andric ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {}); // since C++20 442753f127fSDimitry Andric 443753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 444753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 445753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 446753f127fSDimitry Andric ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {}); // since C++20 447753f127fSDimitry Andric 44881ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 44981ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 45081ad6265SDimitry Andric constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 45181ad6265SDimitry Andric 45281ad6265SDimitry Andric template<forward_range R, class T, class Proj = identity, 45381ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp = 45481ad6265SDimitry Andric ranges::less> 45581ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 45681ad6265SDimitry Andric upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 45781ad6265SDimitry Andric 45881ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 45981ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 46081ad6265SDimitry Andric constexpr I lower_bound(I first, S last, const T& value, Comp comp = {}, 46181ad6265SDimitry Andric Proj proj = {}); // since C++20 46281ad6265SDimitry Andric template<forward_range R, class T, class Proj = identity, 46381ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp = 46481ad6265SDimitry Andric ranges::less> 46581ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 46681ad6265SDimitry Andric lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 46781ad6265SDimitry Andric 46881ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 46981ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 47081ad6265SDimitry Andric constexpr bool binary_search(I first, S last, const T& value, Comp comp = {}, 47181ad6265SDimitry Andric Proj proj = {}); // since C++20 47281ad6265SDimitry Andric 47381ad6265SDimitry Andric template<forward_range R, class T, class Proj = identity, 47481ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp = 47581ad6265SDimitry Andric ranges::less> 47681ad6265SDimitry Andric constexpr bool binary_search(R&& r, const T& value, Comp comp = {}, 47781ad6265SDimitry Andric Proj proj = {}); // since C++20 478fcaf7f86SDimitry Andric 479fcaf7f86SDimitry Andric template<permutable I, sentinel_for<I> S, class Proj = identity, 480fcaf7f86SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 481fcaf7f86SDimitry Andric constexpr subrange<I> 482fcaf7f86SDimitry Andric partition(I first, S last, Pred pred, Proj proj = {}); // Since C++20 483fcaf7f86SDimitry Andric 484fcaf7f86SDimitry Andric template<forward_range R, class Proj = identity, 485fcaf7f86SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 486fcaf7f86SDimitry Andric requires permutable<iterator_t<R>> 487fcaf7f86SDimitry Andric constexpr borrowed_subrange_t<R> 488fcaf7f86SDimitry Andric partition(R&& r, Pred pred, Proj proj = {}); // Since C++20 489fcaf7f86SDimitry Andric 490fcaf7f86SDimitry Andric template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity, 491fcaf7f86SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 492fcaf7f86SDimitry Andric requires permutable<I> 493fcaf7f86SDimitry Andric subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {}); // Since C++20 494fcaf7f86SDimitry Andric 495fcaf7f86SDimitry Andric template<bidirectional_range R, class Proj = identity, 496fcaf7f86SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 497fcaf7f86SDimitry Andric requires permutable<iterator_t<R>> 498fcaf7f86SDimitry Andric borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {}); // Since C++20 499fcaf7f86SDimitry Andric 50081ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2, 50181ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 50281ad6265SDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 50381ad6265SDimitry Andric constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, 50481ad6265SDimitry Andric Pred pred = {}, 50581ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 50681ad6265SDimitry Andric 50781ad6265SDimitry Andric template<input_range R1, forward_range R2, 50881ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 50981ad6265SDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 51081ad6265SDimitry Andric constexpr borrowed_iterator_t<R1> 51181ad6265SDimitry Andric ranges::find_first_of(R1&& r1, R2&& r2, 51281ad6265SDimitry Andric Pred pred = {}, 51381ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 51481ad6265SDimitry Andric 51581ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 51681ad6265SDimitry Andric indirect_binary_predicate<projected<I, Proj>, 51781ad6265SDimitry Andric projected<I, Proj>> Pred = ranges::equal_to> 51881ad6265SDimitry Andric constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {}); // since C+20 51981ad6265SDimitry Andric 52081ad6265SDimitry Andric template<forward_range R, class Proj = identity, 52181ad6265SDimitry Andric indirect_binary_predicate<projected<iterator_t<R>, Proj>, 52281ad6265SDimitry Andric projected<iterator_t<R>, Proj>> Pred = ranges::equal_to> 52381ad6265SDimitry Andric constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // since C++20 52481ad6265SDimitry Andric 52581ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity> 52681ad6265SDimitry Andric requires indirectly_writable<I, const T2&> && 52781ad6265SDimitry Andric indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> 52881ad6265SDimitry Andric constexpr I 52981ad6265SDimitry Andric ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20 53081ad6265SDimitry Andric 53181ad6265SDimitry Andric template<input_range R, class T1, class T2, class Proj = identity> 53281ad6265SDimitry Andric requires indirectly_writable<iterator_t<R>, const T2&> && 53381ad6265SDimitry Andric indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*> 53481ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 53581ad6265SDimitry Andric ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20 53681ad6265SDimitry Andric 53781ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity, 53881ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 53981ad6265SDimitry Andric requires indirectly_writable<I, const T&> 54081ad6265SDimitry Andric constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20 54181ad6265SDimitry Andric 54281ad6265SDimitry Andric template<input_range R, class T, class Proj = identity, 54381ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 54481ad6265SDimitry Andric requires indirectly_writable<iterator_t<R>, const T&> 54581ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 54681ad6265SDimitry Andric ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {}); // since C++20 54781ad6265SDimitry Andric 54881ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 54981ad6265SDimitry Andric class Proj1 = identity, class Proj2 = identity, 55081ad6265SDimitry Andric indirect_strict_weak_order<projected<I1, Proj1>, 55181ad6265SDimitry Andric projected<I2, Proj2>> Comp = ranges::less> 55281ad6265SDimitry Andric constexpr bool 55381ad6265SDimitry Andric ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2, 55481ad6265SDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 55581ad6265SDimitry Andric 55681ad6265SDimitry Andric template<input_range R1, input_range R2, class Proj1 = identity, 55781ad6265SDimitry Andric class Proj2 = identity, 55881ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>, 55981ad6265SDimitry Andric projected<iterator_t<R2>, Proj2>> Comp = ranges::less> 56081ad6265SDimitry Andric constexpr bool 56181ad6265SDimitry Andric ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {}, 56281ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 56381ad6265SDimitry Andric 56481ad6265SDimitry Andric template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2> 56581ad6265SDimitry Andric requires indirectly_movable<I1, I2> 56681ad6265SDimitry Andric constexpr ranges::move_backward_result<I1, I2> 56781ad6265SDimitry Andric ranges::move_backward(I1 first, S1 last, I2 result); // since C++20 56881ad6265SDimitry Andric 56981ad6265SDimitry Andric template<bidirectional_range R, bidirectional_iterator I> 57081ad6265SDimitry Andric requires indirectly_movable<iterator_t<R>, I> 57181ad6265SDimitry Andric constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I> 57281ad6265SDimitry Andric ranges::move_backward(R&& r, I result); // since C++20 57381ad6265SDimitry Andric 57481ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, weakly_incrementable O> 57581ad6265SDimitry Andric requires indirectly_movable<I, O> 57681ad6265SDimitry Andric constexpr ranges::move_result<I, O> 57781ad6265SDimitry Andric ranges::move(I first, S last, O result); // since C++20 57881ad6265SDimitry Andric 57981ad6265SDimitry Andric template<input_range R, weakly_incrementable O> 58081ad6265SDimitry Andric requires indirectly_movable<iterator_t<R>, O> 58181ad6265SDimitry Andric constexpr ranges::move_result<borrowed_iterator_t<R>, O> 58281ad6265SDimitry Andric ranges::move(R&& r, O result); // since C++20 58381ad6265SDimitry Andric 584fcaf7f86SDimitry Andric template<class I, class O1, class O2> 585fcaf7f86SDimitry Andric using partition_copy_result = in_out_out_result<I, O1, O2>; // since C++20 586fcaf7f86SDimitry Andric 587fcaf7f86SDimitry Andric template<input_iterator I, sentinel_for<I> S, 588fcaf7f86SDimitry Andric weakly_incrementable O1, weakly_incrementable O2, 589fcaf7f86SDimitry Andric class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred> 590fcaf7f86SDimitry Andric requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2> 591fcaf7f86SDimitry Andric constexpr partition_copy_result<I, O1, O2> 592fcaf7f86SDimitry Andric partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred, 593fcaf7f86SDimitry Andric Proj proj = {}); // Since C++20 594fcaf7f86SDimitry Andric 595fcaf7f86SDimitry Andric template<input_range R, weakly_incrementable O1, weakly_incrementable O2, 596fcaf7f86SDimitry Andric class Proj = identity, 597fcaf7f86SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 598fcaf7f86SDimitry Andric requires indirectly_copyable<iterator_t<R>, O1> && 599fcaf7f86SDimitry Andric indirectly_copyable<iterator_t<R>, O2> 600fcaf7f86SDimitry Andric constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2> 601fcaf7f86SDimitry Andric partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {}); // Since C++20 602fcaf7f86SDimitry Andric 603fcaf7f86SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 604fcaf7f86SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 605fcaf7f86SDimitry Andric constexpr I partition_point(I first, S last, Pred pred, Proj proj = {}); // Since C++20 606fcaf7f86SDimitry Andric 607fcaf7f86SDimitry Andric template<forward_range R, class Proj = identity, 608fcaf7f86SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 609fcaf7f86SDimitry Andric constexpr borrowed_iterator_t<R> 610fcaf7f86SDimitry Andric partition_point(R&& r, Pred pred, Proj proj = {}); // Since C++20 611fcaf7f86SDimitry Andric 612753f127fSDimitry Andric template<class I1, class I2, class O> 613753f127fSDimitry Andric using merge_result = in_in_out_result<I1, I2, O>; // since C++20 614753f127fSDimitry Andric 615753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 616753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, 617753f127fSDimitry Andric class Proj2 = identity> 618753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 619753f127fSDimitry Andric constexpr merge_result<I1, I2, O> 620753f127fSDimitry Andric merge(I1 first1, S1 last1, I2 first2, S2 last2, O result, 621753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 622753f127fSDimitry Andric 623753f127fSDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less, 624753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 625753f127fSDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 626753f127fSDimitry Andric constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> 627753f127fSDimitry Andric merge(R1&& r1, R2&& r2, O result, 628753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 629753f127fSDimitry Andric 630753f127fSDimitry Andric template<permutable I, sentinel_for<I> S, class T, class Proj = identity> 631753f127fSDimitry Andric requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*> 632753f127fSDimitry Andric constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {}); // since C++20 633753f127fSDimitry Andric 634753f127fSDimitry Andric template<forward_range R, class T, class Proj = identity> 635753f127fSDimitry Andric requires permutable<iterator_t<R>> && 636753f127fSDimitry Andric indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> 637753f127fSDimitry Andric constexpr borrowed_subrange_t<R> 638753f127fSDimitry Andric ranges::remove(R&& r, const T& value, Proj proj = {}); // since C++20 639753f127fSDimitry Andric 640753f127fSDimitry Andric template<permutable I, sentinel_for<I> S, class Proj = identity, 641753f127fSDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 642753f127fSDimitry Andric constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {}); // since C++20 643753f127fSDimitry Andric 644753f127fSDimitry Andric template<forward_range R, class Proj = identity, 645753f127fSDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 646753f127fSDimitry Andric requires permutable<iterator_t<R>> 647753f127fSDimitry Andric constexpr borrowed_subrange_t<R> 648753f127fSDimitry Andric ranges::remove_if(R&& r, Pred pred, Proj proj = {}); // since C++20 649753f127fSDimitry Andric 650753f127fSDimitry Andric template<class I, class O> 651753f127fSDimitry Andric using set_difference_result = in_out_result<I, O>; // since C++20 652753f127fSDimitry Andric 653753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 654753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 655753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 656753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 657753f127fSDimitry Andric constexpr set_difference_result<I1, O> 658753f127fSDimitry Andric set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result, 659753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 660753f127fSDimitry Andric 661753f127fSDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, 662753f127fSDimitry Andric class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> 663753f127fSDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 664753f127fSDimitry Andric constexpr set_difference_result<borrowed_iterator_t<R1>, O> 665753f127fSDimitry Andric set_difference(R1&& r1, R2&& r2, O result, 666753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 667753f127fSDimitry Andric 668753f127fSDimitry Andric template<class I1, class I2, class O> 669753f127fSDimitry Andric using set_intersection_result = in_in_out_result<I1, I2, O>; // since C++20 670753f127fSDimitry Andric 671753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 672753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 673753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 674753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 675753f127fSDimitry Andric constexpr set_intersection_result<I1, I2, O> 676753f127fSDimitry Andric set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result, 677753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 678753f127fSDimitry Andric 679753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 680753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 681753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 682753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 683753f127fSDimitry Andric constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> 684753f127fSDimitry Andric set_intersection(R1&& r1, R2&& r2, O result, 685753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 686753f127fSDimitry Andric 687753f127fSDimitry Andric template <class _InIter, class _OutIter> 688753f127fSDimitry Andric using reverse_copy_result = in_out_result<_InIter, _OutIter>; // since C++20 689753f127fSDimitry Andric 690753f127fSDimitry Andric template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O> 691753f127fSDimitry Andric requires indirectly_copyable<I, O> 692753f127fSDimitry Andric constexpr ranges::reverse_copy_result<I, O> 693753f127fSDimitry Andric ranges::reverse_copy(I first, S last, O result); // since C++20 694753f127fSDimitry Andric 695753f127fSDimitry Andric template<bidirectional_range R, weakly_incrementable O> 696753f127fSDimitry Andric requires indirectly_copyable<iterator_t<R>, O> 697753f127fSDimitry Andric constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O> 698753f127fSDimitry Andric ranges::reverse_copy(R&& r, O result); // since C++20 699753f127fSDimitry Andric 700753f127fSDimitry Andric template <class _InIter, class _OutIter> 701753f127fSDimitry Andric using rotate_copy_result = in_out_result<_InIter, _OutIter>; // since C++20 702753f127fSDimitry Andric 703753f127fSDimitry Andric template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O> 704753f127fSDimitry Andric requires indirectly_copyable<I, O> 705753f127fSDimitry Andric constexpr ranges::rotate_copy_result<I, O> 706753f127fSDimitry Andric ranges::rotate_copy(I first, I middle, S last, O result); // since C++20 707753f127fSDimitry Andric 708753f127fSDimitry Andric template<forward_range R, weakly_incrementable O> 709753f127fSDimitry Andric requires indirectly_copyable<iterator_t<R>, O> 710753f127fSDimitry Andric constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O> 711753f127fSDimitry Andric ranges::rotate_copy(R&& r, iterator_t<R> middle, O result); // since C++20 712753f127fSDimitry Andric 713fcaf7f86SDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Gen> 714fcaf7f86SDimitry Andric requires permutable<I> && 715fcaf7f86SDimitry Andric uniform_random_bit_generator<remove_reference_t<Gen>> 716fcaf7f86SDimitry Andric I shuffle(I first, S last, Gen&& g); // Since C++20 717fcaf7f86SDimitry Andric 718fcaf7f86SDimitry Andric template<random_access_range R, class Gen> 719fcaf7f86SDimitry Andric requires permutable<iterator_t<R>> && 720fcaf7f86SDimitry Andric uniform_random_bit_generator<remove_reference_t<Gen>> 721fcaf7f86SDimitry Andric borrowed_iterator_t<R> shuffle(R&& r, Gen&& g); // Since C++20 722fcaf7f86SDimitry Andric 723753f127fSDimitry Andric template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, 724753f127fSDimitry Andric sentinel_for<I2> S2, class Pred = ranges::equal_to, 725753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 726753f127fSDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 727753f127fSDimitry Andric constexpr subrange<I1> 728753f127fSDimitry Andric ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, 729753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 730753f127fSDimitry Andric 731753f127fSDimitry Andric template<forward_range R1, forward_range R2, class Pred = ranges::equal_to, 732753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 733753f127fSDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 734753f127fSDimitry Andric constexpr borrowed_subrange_t<R1> 735753f127fSDimitry Andric ranges::search(R1&& r1, R2&& r2, Pred pred = {}, 736753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 737753f127fSDimitry Andric 738753f127fSDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, 739753f127fSDimitry Andric class Pred = ranges::equal_to, class Proj = identity> 740753f127fSDimitry Andric requires indirectly_comparable<I, const T*, Pred, Proj> 741753f127fSDimitry Andric constexpr subrange<I> 742753f127fSDimitry Andric ranges::search_n(I first, S last, iter_difference_t<I> count, 743753f127fSDimitry Andric const T& value, Pred pred = {}, Proj proj = {}); // since C++20 744753f127fSDimitry Andric 745753f127fSDimitry Andric template<forward_range R, class T, class Pred = ranges::equal_to, 746753f127fSDimitry Andric class Proj = identity> 747753f127fSDimitry Andric requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj> 748753f127fSDimitry Andric constexpr borrowed_subrange_t<R> 749753f127fSDimitry Andric ranges::search_n(R&& r, range_difference_t<R> count, 750753f127fSDimitry Andric const T& value, Pred pred = {}, Proj proj = {}); // since C++20 751753f127fSDimitry Andric 752753f127fSDimitry Andric template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2, 753753f127fSDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 754753f127fSDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 755753f127fSDimitry Andric constexpr subrange<I1> 756753f127fSDimitry Andric ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, 757753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 758753f127fSDimitry Andric 759753f127fSDimitry Andric template<forward_range R1, forward_range R2, 760753f127fSDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 761753f127fSDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 762753f127fSDimitry Andric constexpr borrowed_subrange_t<R1> 763753f127fSDimitry Andric ranges::find_end(R1&& r1, R2&& r2, Pred pred = {}, 764753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 765753f127fSDimitry Andric 766753f127fSDimitry Andric template<class I1, class I2, class O> 767753f127fSDimitry Andric using set_symmetric_difference_result = in_in_out_result<I1, I2, O>; // since C++20 768753f127fSDimitry Andric 769753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 770753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 771753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 772753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 773753f127fSDimitry Andric constexpr set_symmetric_difference_result<I1, I2, O> 774753f127fSDimitry Andric set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result, 775753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, 776753f127fSDimitry Andric Proj2 proj2 = {}); // since C++20 777753f127fSDimitry Andric 778753f127fSDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, 779753f127fSDimitry Andric class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> 780753f127fSDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 781753f127fSDimitry Andric constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>, 782753f127fSDimitry Andric borrowed_iterator_t<R2>, O> 783753f127fSDimitry Andric set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {}, 784753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 78581ad6265SDimitry Andric 786fcaf7f86SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 787fcaf7f86SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 788fcaf7f86SDimitry Andric constexpr subrange<I> 789fcaf7f86SDimitry Andric equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 790fcaf7f86SDimitry Andric 791fcaf7f86SDimitry Andric template<forward_range R, class T, class Proj = identity, 792fcaf7f86SDimitry Andric indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp = 793fcaf7f86SDimitry Andric ranges::less> 794fcaf7f86SDimitry Andric constexpr borrowed_subrange_t<R> 795fcaf7f86SDimitry Andric equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 796fcaf7f86SDimitry Andric 797fcaf7f86SDimitry Andric template<class I1, class I2, class O> 798fcaf7f86SDimitry Andric using set_union_result = in_in_out_result<I1, I2, O>; // since C++20 799fcaf7f86SDimitry Andric 800fcaf7f86SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 801fcaf7f86SDimitry Andric weakly_incrementable O, class Comp = ranges::less, 802fcaf7f86SDimitry Andric class Proj1 = identity, class Proj2 = identity> 803fcaf7f86SDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 804fcaf7f86SDimitry Andric constexpr set_union_result<I1, I2, O> 805fcaf7f86SDimitry Andric set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {}, 806fcaf7f86SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 807fcaf7f86SDimitry Andric 808fcaf7f86SDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, 809fcaf7f86SDimitry Andric class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> 810fcaf7f86SDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 811fcaf7f86SDimitry Andric constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> 812fcaf7f86SDimitry Andric set_union(R1&& r1, R2&& r2, O result, Comp comp = {}, 813fcaf7f86SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 814fcaf7f86SDimitry Andric 815fcaf7f86SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 816fcaf7f86SDimitry Andric class Proj1 = identity, class Proj2 = identity, 817fcaf7f86SDimitry Andric indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp = 818fcaf7f86SDimitry Andric ranges::less> 819fcaf7f86SDimitry Andric constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {}, 820fcaf7f86SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // Since C++20 821fcaf7f86SDimitry Andric 822fcaf7f86SDimitry Andric template<input_range R1, input_range R2, class Proj1 = identity, 823fcaf7f86SDimitry Andric class Proj2 = identity, 824fcaf7f86SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>, 825fcaf7f86SDimitry Andric projected<iterator_t<R2>, Proj2>> Comp = ranges::less> 826fcaf7f86SDimitry Andric constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {}, 827fcaf7f86SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // Since C++20 82804eeddc0SDimitry Andric} 82904eeddc0SDimitry Andric 830*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 831*0b57cec5SDimitry Andric all_of(InputIterator first, InputIterator last, Predicate pred); 832*0b57cec5SDimitry Andric 833*0b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 834*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 835*0b57cec5SDimitry Andric any_of(InputIterator first, InputIterator last, Predicate pred); 836*0b57cec5SDimitry Andric 837*0b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 838*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 839*0b57cec5SDimitry Andric none_of(InputIterator first, InputIterator last, Predicate pred); 840*0b57cec5SDimitry Andric 841*0b57cec5SDimitry Andrictemplate <class InputIterator, class Function> 842*0b57cec5SDimitry Andric constexpr Function // constexpr in C++20 843*0b57cec5SDimitry Andric for_each(InputIterator first, InputIterator last, Function f); 844*0b57cec5SDimitry Andric 845*0b57cec5SDimitry Andrictemplate<class InputIterator, class Size, class Function> 846*0b57cec5SDimitry Andric constexpr InputIterator // constexpr in C++20 847*0b57cec5SDimitry Andric for_each_n(InputIterator first, Size n, Function f); // C++17 848*0b57cec5SDimitry Andric 849*0b57cec5SDimitry Andrictemplate <class InputIterator, class T> 850*0b57cec5SDimitry Andric constexpr InputIterator // constexpr in C++20 851*0b57cec5SDimitry Andric find(InputIterator first, InputIterator last, const T& value); 852*0b57cec5SDimitry Andric 853*0b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 854*0b57cec5SDimitry Andric constexpr InputIterator // constexpr in C++20 855*0b57cec5SDimitry Andric find_if(InputIterator first, InputIterator last, Predicate pred); 856*0b57cec5SDimitry Andric 857*0b57cec5SDimitry Andrictemplate<class InputIterator, class Predicate> 858e8d8bef9SDimitry Andric constexpr InputIterator // constexpr in C++20 859*0b57cec5SDimitry Andric find_if_not(InputIterator first, InputIterator last, Predicate pred); 860*0b57cec5SDimitry Andric 861*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 862e8d8bef9SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 863*0b57cec5SDimitry Andric find_end(ForwardIterator1 first1, ForwardIterator1 last1, 864*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); 865*0b57cec5SDimitry Andric 866*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 867e8d8bef9SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 868*0b57cec5SDimitry Andric find_end(ForwardIterator1 first1, ForwardIterator1 last1, 869*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 870*0b57cec5SDimitry Andric 871*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 872*0b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 873*0b57cec5SDimitry Andric find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 874*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); 875*0b57cec5SDimitry Andric 876*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 877*0b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 878*0b57cec5SDimitry Andric find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 879*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 880*0b57cec5SDimitry Andric 881*0b57cec5SDimitry Andrictemplate <class ForwardIterator> 882*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 883*0b57cec5SDimitry Andric adjacent_find(ForwardIterator first, ForwardIterator last); 884*0b57cec5SDimitry Andric 885*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class BinaryPredicate> 886*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 887*0b57cec5SDimitry Andric adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 888*0b57cec5SDimitry Andric 889*0b57cec5SDimitry Andrictemplate <class InputIterator, class T> 890*0b57cec5SDimitry Andric constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20 891*0b57cec5SDimitry Andric count(InputIterator first, InputIterator last, const T& value); 892*0b57cec5SDimitry Andric 893*0b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 894*0b57cec5SDimitry Andric constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20 895*0b57cec5SDimitry Andric count_if(InputIterator first, InputIterator last, Predicate pred); 896*0b57cec5SDimitry Andric 897*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 898*0b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 899*0b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 900*0b57cec5SDimitry Andric 901*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 902*0b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 903*0b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, 904*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2); // **C++14** 905*0b57cec5SDimitry Andric 906*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 907*0b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 908*0b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, 909*0b57cec5SDimitry Andric InputIterator2 first2, BinaryPredicate pred); 910*0b57cec5SDimitry Andric 911*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 912*0b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 913*0b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, 914*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, 915*0b57cec5SDimitry Andric BinaryPredicate pred); // **C++14** 916*0b57cec5SDimitry Andric 917*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 918*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 919*0b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 920*0b57cec5SDimitry Andric 921*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 922*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 923*0b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, 924*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2); // **C++14** 925*0b57cec5SDimitry Andric 926*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 927*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 928*0b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, 929*0b57cec5SDimitry Andric InputIterator2 first2, BinaryPredicate pred); 930*0b57cec5SDimitry Andric 931*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 932*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 933*0b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, 934*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, 935*0b57cec5SDimitry Andric BinaryPredicate pred); // **C++14** 936*0b57cec5SDimitry Andric 937*0b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2> 938*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 939*0b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 940*0b57cec5SDimitry Andric ForwardIterator2 first2); 941*0b57cec5SDimitry Andric 942*0b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2> 943*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 944*0b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 945*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); // **C++14** 946*0b57cec5SDimitry Andric 947*0b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 948*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 949*0b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 950*0b57cec5SDimitry Andric ForwardIterator2 first2, BinaryPredicate pred); 951*0b57cec5SDimitry Andric 952*0b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 953*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 954*0b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 955*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, 956*0b57cec5SDimitry Andric BinaryPredicate pred); // **C++14** 957*0b57cec5SDimitry Andric 958*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 959*0b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 960*0b57cec5SDimitry Andric search(ForwardIterator1 first1, ForwardIterator1 last1, 961*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); 962*0b57cec5SDimitry Andric 963*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 964*0b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 965*0b57cec5SDimitry Andric search(ForwardIterator1 first1, ForwardIterator1 last1, 966*0b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 967*0b57cec5SDimitry Andric 968*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Size, class T> 969*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 970*0b57cec5SDimitry Andric search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); 971*0b57cec5SDimitry Andric 972*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Size, class T, class BinaryPredicate> 973*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 974*0b57cec5SDimitry Andric search_n(ForwardIterator first, ForwardIterator last, 975*0b57cec5SDimitry Andric Size count, const T& value, BinaryPredicate pred); 976*0b57cec5SDimitry Andric 977*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator> 978480093f4SDimitry Andric constexpr OutputIterator // constexpr in C++20 979*0b57cec5SDimitry Andric copy(InputIterator first, InputIterator last, OutputIterator result); 980*0b57cec5SDimitry Andric 981*0b57cec5SDimitry Andrictemplate<class InputIterator, class OutputIterator, class Predicate> 982480093f4SDimitry Andric constexpr OutputIterator // constexpr in C++20 983*0b57cec5SDimitry Andric copy_if(InputIterator first, InputIterator last, 984*0b57cec5SDimitry Andric OutputIterator result, Predicate pred); 985*0b57cec5SDimitry Andric 986*0b57cec5SDimitry Andrictemplate<class InputIterator, class Size, class OutputIterator> 987480093f4SDimitry Andric constexpr OutputIterator // constexpr in C++20 988*0b57cec5SDimitry Andric copy_n(InputIterator first, Size n, OutputIterator result); 989*0b57cec5SDimitry Andric 990*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator1, class BidirectionalIterator2> 991480093f4SDimitry Andric constexpr BidirectionalIterator2 // constexpr in C++20 992*0b57cec5SDimitry Andric copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 993*0b57cec5SDimitry Andric BidirectionalIterator2 result); 994*0b57cec5SDimitry Andric 99581ad6265SDimitry Andric// [alg.move], move 99681ad6265SDimitry Andrictemplate<class InputIterator, class OutputIterator> 99781ad6265SDimitry Andric constexpr OutputIterator move(InputIterator first, InputIterator last, 99881ad6265SDimitry Andric OutputIterator result); 99981ad6265SDimitry Andric 100081ad6265SDimitry Andrictemplate<class BidirectionalIterator1, class BidirectionalIterator2> 100181ad6265SDimitry Andric constexpr BidirectionalIterator2 100281ad6265SDimitry Andric move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 100381ad6265SDimitry Andric BidirectionalIterator2 result); 100481ad6265SDimitry Andric 1005*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 1006e8d8bef9SDimitry Andric constexpr ForwardIterator2 // constexpr in C++20 1007*0b57cec5SDimitry Andric swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); 1008*0b57cec5SDimitry Andric 100981ad6265SDimitry Andricnamespace ranges { 101081ad6265SDimitry Andric template<class I1, class I2> 101181ad6265SDimitry Andric using swap_ranges_result = in_in_result<I1, I2>; 101281ad6265SDimitry Andric 101381ad6265SDimitry Andrictemplate<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2> 101481ad6265SDimitry Andric requires indirectly_swappable<I1, I2> 101581ad6265SDimitry Andric constexpr ranges::swap_ranges_result<I1, I2> 101681ad6265SDimitry Andric swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2); 101781ad6265SDimitry Andric 101881ad6265SDimitry Andrictemplate<input_range R1, input_range R2> 101981ad6265SDimitry Andric requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>> 102081ad6265SDimitry Andric constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> 102181ad6265SDimitry Andric swap_ranges(R1&& r1, R2&& r2); 102281ad6265SDimitry Andric} 102381ad6265SDimitry Andric 1024*0b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 1025e8d8bef9SDimitry Andric constexpr void // constexpr in C++20 1026*0b57cec5SDimitry Andric iter_swap(ForwardIterator1 a, ForwardIterator2 b); 1027*0b57cec5SDimitry Andric 1028*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class UnaryOperation> 1029*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1030*0b57cec5SDimitry Andric transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); 1031*0b57cec5SDimitry Andric 1032*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> 1033*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1034*0b57cec5SDimitry Andric transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, 1035*0b57cec5SDimitry Andric OutputIterator result, BinaryOperation binary_op); 1036*0b57cec5SDimitry Andric 1037*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1038*0b57cec5SDimitry Andric constexpr void // constexpr in C++20 1039*0b57cec5SDimitry Andric replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); 1040*0b57cec5SDimitry Andric 1041*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate, class T> 1042*0b57cec5SDimitry Andric constexpr void // constexpr in C++20 1043*0b57cec5SDimitry Andric replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); 1044*0b57cec5SDimitry Andric 1045*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class T> 1046*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1047*0b57cec5SDimitry Andric replace_copy(InputIterator first, InputIterator last, OutputIterator result, 1048*0b57cec5SDimitry Andric const T& old_value, const T& new_value); 1049*0b57cec5SDimitry Andric 1050*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class Predicate, class T> 1051*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1052*0b57cec5SDimitry Andric replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value); 1053*0b57cec5SDimitry Andric 1054*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1055*0b57cec5SDimitry Andric constexpr void // constexpr in C++20 1056*0b57cec5SDimitry Andric fill(ForwardIterator first, ForwardIterator last, const T& value); 1057*0b57cec5SDimitry Andric 1058*0b57cec5SDimitry Andrictemplate <class OutputIterator, class Size, class T> 1059*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1060*0b57cec5SDimitry Andric fill_n(OutputIterator first, Size n, const T& value); 1061*0b57cec5SDimitry Andric 1062*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Generator> 1063*0b57cec5SDimitry Andric constexpr void // constexpr in C++20 1064*0b57cec5SDimitry Andric generate(ForwardIterator first, ForwardIterator last, Generator gen); 1065*0b57cec5SDimitry Andric 1066*0b57cec5SDimitry Andrictemplate <class OutputIterator, class Size, class Generator> 1067*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1068*0b57cec5SDimitry Andric generate_n(OutputIterator first, Size n, Generator gen); 1069*0b57cec5SDimitry Andric 1070*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1071*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1072*0b57cec5SDimitry Andric remove(ForwardIterator first, ForwardIterator last, const T& value); 1073*0b57cec5SDimitry Andric 1074*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate> 1075*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1076*0b57cec5SDimitry Andric remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); 1077*0b57cec5SDimitry Andric 1078*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class T> 1079*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1080*0b57cec5SDimitry Andric remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); 1081*0b57cec5SDimitry Andric 1082*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class Predicate> 1083*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1084*0b57cec5SDimitry Andric remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); 1085*0b57cec5SDimitry Andric 1086*0b57cec5SDimitry Andrictemplate <class ForwardIterator> 1087e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1088*0b57cec5SDimitry Andric unique(ForwardIterator first, ForwardIterator last); 1089*0b57cec5SDimitry Andric 1090*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class BinaryPredicate> 1091e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1092*0b57cec5SDimitry Andric unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 1093*0b57cec5SDimitry Andric 1094*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator> 1095e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1096*0b57cec5SDimitry Andric unique_copy(InputIterator first, InputIterator last, OutputIterator result); 1097*0b57cec5SDimitry Andric 1098*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class BinaryPredicate> 1099e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1100*0b57cec5SDimitry Andric unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); 1101*0b57cec5SDimitry Andric 1102*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 1103e8d8bef9SDimitry Andric constexpr void // constexpr in C++20 1104*0b57cec5SDimitry Andric reverse(BidirectionalIterator first, BidirectionalIterator last); 1105*0b57cec5SDimitry Andric 1106*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class OutputIterator> 1107*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1108*0b57cec5SDimitry Andric reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); 1109*0b57cec5SDimitry Andric 1110*0b57cec5SDimitry Andrictemplate <class ForwardIterator> 1111e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1112*0b57cec5SDimitry Andric rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); 1113*0b57cec5SDimitry Andric 1114*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class OutputIterator> 1115e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1116*0b57cec5SDimitry Andric rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); 1117*0b57cec5SDimitry Andric 1118*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1119*0b57cec5SDimitry Andric void 1120*0b57cec5SDimitry Andric random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17 1121*0b57cec5SDimitry Andric 1122*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class RandomNumberGenerator> 1123*0b57cec5SDimitry Andric void 1124*0b57cec5SDimitry Andric random_shuffle(RandomAccessIterator first, RandomAccessIterator last, 1125*0b57cec5SDimitry Andric RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17 1126*0b57cec5SDimitry Andric 1127*0b57cec5SDimitry Andrictemplate<class PopulationIterator, class SampleIterator, 1128*0b57cec5SDimitry Andric class Distance, class UniformRandomBitGenerator> 1129*0b57cec5SDimitry Andric SampleIterator sample(PopulationIterator first, PopulationIterator last, 1130*0b57cec5SDimitry Andric SampleIterator out, Distance n, 1131*0b57cec5SDimitry Andric UniformRandomBitGenerator&& g); // C++17 1132*0b57cec5SDimitry Andric 1133*0b57cec5SDimitry Andrictemplate<class RandomAccessIterator, class UniformRandomNumberGenerator> 1134*0b57cec5SDimitry Andric void shuffle(RandomAccessIterator first, RandomAccessIterator last, 1135*0b57cec5SDimitry Andric UniformRandomNumberGenerator&& g); 1136*0b57cec5SDimitry Andric 1137e8d8bef9SDimitry Andrictemplate<class ForwardIterator> 1138e8d8bef9SDimitry Andric constexpr ForwardIterator 1139e8d8bef9SDimitry Andric shift_left(ForwardIterator first, ForwardIterator last, 1140e8d8bef9SDimitry Andric typename iterator_traits<ForwardIterator>::difference_type n); // C++20 1141e8d8bef9SDimitry Andric 1142e8d8bef9SDimitry Andrictemplate<class ForwardIterator> 1143e8d8bef9SDimitry Andric constexpr ForwardIterator 1144e8d8bef9SDimitry Andric shift_right(ForwardIterator first, ForwardIterator last, 1145e8d8bef9SDimitry Andric typename iterator_traits<ForwardIterator>::difference_type n); // C++20 1146e8d8bef9SDimitry Andric 1147*0b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 1148*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1149*0b57cec5SDimitry Andric is_partitioned(InputIterator first, InputIterator last, Predicate pred); 1150*0b57cec5SDimitry Andric 1151*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate> 1152e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1153*0b57cec5SDimitry Andric partition(ForwardIterator first, ForwardIterator last, Predicate pred); 1154*0b57cec5SDimitry Andric 1155*0b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator1, 1156*0b57cec5SDimitry Andric class OutputIterator2, class Predicate> 1157*0b57cec5SDimitry Andric constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20 1158*0b57cec5SDimitry Andric partition_copy(InputIterator first, InputIterator last, 1159*0b57cec5SDimitry Andric OutputIterator1 out_true, OutputIterator2 out_false, 1160*0b57cec5SDimitry Andric Predicate pred); 1161*0b57cec5SDimitry Andric 1162*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate> 1163*0b57cec5SDimitry Andric ForwardIterator 1164*0b57cec5SDimitry Andric stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred); 1165*0b57cec5SDimitry Andric 1166*0b57cec5SDimitry Andrictemplate<class ForwardIterator, class Predicate> 1167*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1168*0b57cec5SDimitry Andric partition_point(ForwardIterator first, ForwardIterator last, Predicate pred); 1169*0b57cec5SDimitry Andric 1170*0b57cec5SDimitry Andrictemplate <class ForwardIterator> 1171*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1172*0b57cec5SDimitry Andric is_sorted(ForwardIterator first, ForwardIterator last); 1173*0b57cec5SDimitry Andric 1174*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1175e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 1176*0b57cec5SDimitry Andric is_sorted(ForwardIterator first, ForwardIterator last, Compare comp); 1177*0b57cec5SDimitry Andric 1178*0b57cec5SDimitry Andrictemplate<class ForwardIterator> 1179*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1180*0b57cec5SDimitry Andric is_sorted_until(ForwardIterator first, ForwardIterator last); 1181*0b57cec5SDimitry Andric 1182*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1183*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1184*0b57cec5SDimitry Andric is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp); 1185*0b57cec5SDimitry Andric 1186*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1187fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1188*0b57cec5SDimitry Andric sort(RandomAccessIterator first, RandomAccessIterator last); 1189*0b57cec5SDimitry Andric 1190*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1191fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1192*0b57cec5SDimitry Andric sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 1193*0b57cec5SDimitry Andric 1194*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1195*0b57cec5SDimitry Andric void 1196*0b57cec5SDimitry Andric stable_sort(RandomAccessIterator first, RandomAccessIterator last); 1197*0b57cec5SDimitry Andric 1198*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1199*0b57cec5SDimitry Andric void 1200*0b57cec5SDimitry Andric stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 1201*0b57cec5SDimitry Andric 1202*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1203fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1204*0b57cec5SDimitry Andric partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); 1205*0b57cec5SDimitry Andric 1206*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1207fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1208*0b57cec5SDimitry Andric partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); 1209*0b57cec5SDimitry Andric 1210*0b57cec5SDimitry Andrictemplate <class InputIterator, class RandomAccessIterator> 1211fe6060f1SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 1212*0b57cec5SDimitry Andric partial_sort_copy(InputIterator first, InputIterator last, 1213*0b57cec5SDimitry Andric RandomAccessIterator result_first, RandomAccessIterator result_last); 1214*0b57cec5SDimitry Andric 1215*0b57cec5SDimitry Andrictemplate <class InputIterator, class RandomAccessIterator, class Compare> 1216fe6060f1SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 1217*0b57cec5SDimitry Andric partial_sort_copy(InputIterator first, InputIterator last, 1218*0b57cec5SDimitry Andric RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); 1219*0b57cec5SDimitry Andric 1220*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1221fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1222*0b57cec5SDimitry Andric nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); 1223*0b57cec5SDimitry Andric 1224*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1225fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1226*0b57cec5SDimitry Andric nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); 1227*0b57cec5SDimitry Andric 1228*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1229*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1230*0b57cec5SDimitry Andric lower_bound(ForwardIterator first, ForwardIterator last, const T& value); 1231*0b57cec5SDimitry Andric 1232*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 1233*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1234*0b57cec5SDimitry Andric lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 1235*0b57cec5SDimitry Andric 1236*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1237*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1238*0b57cec5SDimitry Andric upper_bound(ForwardIterator first, ForwardIterator last, const T& value); 1239*0b57cec5SDimitry Andric 1240*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 1241*0b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 1242*0b57cec5SDimitry Andric upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 1243*0b57cec5SDimitry Andric 1244*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1245*0b57cec5SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20 1246*0b57cec5SDimitry Andric equal_range(ForwardIterator first, ForwardIterator last, const T& value); 1247*0b57cec5SDimitry Andric 1248*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 1249*0b57cec5SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20 1250*0b57cec5SDimitry Andric equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 1251*0b57cec5SDimitry Andric 1252*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 1253*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1254*0b57cec5SDimitry Andric binary_search(ForwardIterator first, ForwardIterator last, const T& value); 1255*0b57cec5SDimitry Andric 1256*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 1257*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1258*0b57cec5SDimitry Andric binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 1259*0b57cec5SDimitry Andric 1260*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1261e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1262*0b57cec5SDimitry Andric merge(InputIterator1 first1, InputIterator1 last1, 1263*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 1264*0b57cec5SDimitry Andric 1265*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1266e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1267*0b57cec5SDimitry Andric merge(InputIterator1 first1, InputIterator1 last1, 1268*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 1269*0b57cec5SDimitry Andric 1270*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 1271*0b57cec5SDimitry Andric void 1272*0b57cec5SDimitry Andric inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); 1273*0b57cec5SDimitry Andric 1274*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Compare> 1275*0b57cec5SDimitry Andric void 1276*0b57cec5SDimitry Andric inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); 1277*0b57cec5SDimitry Andric 1278*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 1279*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1280*0b57cec5SDimitry Andric includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 1281*0b57cec5SDimitry Andric 1282*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class Compare> 1283*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1284*0b57cec5SDimitry Andric includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); 1285*0b57cec5SDimitry Andric 1286*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1287e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1288*0b57cec5SDimitry Andric set_union(InputIterator1 first1, InputIterator1 last1, 1289*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 1290*0b57cec5SDimitry Andric 1291*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1292e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1293*0b57cec5SDimitry Andric set_union(InputIterator1 first1, InputIterator1 last1, 1294*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 1295*0b57cec5SDimitry Andric 1296*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1297*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1298*0b57cec5SDimitry Andric set_intersection(InputIterator1 first1, InputIterator1 last1, 1299*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 1300*0b57cec5SDimitry Andric 1301*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1302*0b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 1303*0b57cec5SDimitry Andric set_intersection(InputIterator1 first1, InputIterator1 last1, 1304*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 1305*0b57cec5SDimitry Andric 1306*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1307e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1308*0b57cec5SDimitry Andric set_difference(InputIterator1 first1, InputIterator1 last1, 1309*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 1310*0b57cec5SDimitry Andric 1311*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1312e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1313*0b57cec5SDimitry Andric set_difference(InputIterator1 first1, InputIterator1 last1, 1314*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 1315*0b57cec5SDimitry Andric 1316*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1317e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1318*0b57cec5SDimitry Andric set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 1319*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 1320*0b57cec5SDimitry Andric 1321*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1322e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 1323*0b57cec5SDimitry Andric set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 1324*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 1325*0b57cec5SDimitry Andric 1326*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1327fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1328*0b57cec5SDimitry Andric push_heap(RandomAccessIterator first, RandomAccessIterator last); 1329*0b57cec5SDimitry Andric 1330*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1331fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1332*0b57cec5SDimitry Andric push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 1333*0b57cec5SDimitry Andric 1334*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1335fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1336*0b57cec5SDimitry Andric pop_heap(RandomAccessIterator first, RandomAccessIterator last); 1337*0b57cec5SDimitry Andric 1338*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1339fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1340*0b57cec5SDimitry Andric pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 1341*0b57cec5SDimitry Andric 1342*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1343fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1344*0b57cec5SDimitry Andric make_heap(RandomAccessIterator first, RandomAccessIterator last); 1345*0b57cec5SDimitry Andric 1346*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1347fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1348*0b57cec5SDimitry Andric make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 1349*0b57cec5SDimitry Andric 1350*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1351fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1352*0b57cec5SDimitry Andric sort_heap(RandomAccessIterator first, RandomAccessIterator last); 1353*0b57cec5SDimitry Andric 1354*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1355fe6060f1SDimitry Andric constexpr void // constexpr in C++20 1356*0b57cec5SDimitry Andric sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 1357*0b57cec5SDimitry Andric 1358*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1359*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1360*0b57cec5SDimitry Andric is_heap(RandomAccessIterator first, RandomAccessiterator last); 1361*0b57cec5SDimitry Andric 1362*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1363*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1364*0b57cec5SDimitry Andric is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 1365*0b57cec5SDimitry Andric 1366*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1367*0b57cec5SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 1368*0b57cec5SDimitry Andric is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 1369*0b57cec5SDimitry Andric 1370*0b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1371*0b57cec5SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 1372*0b57cec5SDimitry Andric is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 1373*0b57cec5SDimitry Andric 1374*0b57cec5SDimitry Andrictemplate <class ForwardIterator> 1375e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1376e8d8bef9SDimitry Andric min_element(ForwardIterator first, ForwardIterator last); 1377*0b57cec5SDimitry Andric 1378*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1379e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1380e8d8bef9SDimitry Andric min_element(ForwardIterator first, ForwardIterator last, Compare comp); 1381*0b57cec5SDimitry Andric 1382*0b57cec5SDimitry Andrictemplate <class T> 1383e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1384e8d8bef9SDimitry Andric min(const T& a, const T& b); 1385*0b57cec5SDimitry Andric 1386*0b57cec5SDimitry Andrictemplate <class T, class Compare> 1387e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1388e8d8bef9SDimitry Andric min(const T& a, const T& b, Compare comp); 1389*0b57cec5SDimitry Andric 1390*0b57cec5SDimitry Andrictemplate<class T> 1391e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1392e8d8bef9SDimitry Andric min(initializer_list<T> t); 1393*0b57cec5SDimitry Andric 1394*0b57cec5SDimitry Andrictemplate<class T, class Compare> 1395e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1396e8d8bef9SDimitry Andric min(initializer_list<T> t, Compare comp); 1397*0b57cec5SDimitry Andric 1398*0b57cec5SDimitry Andrictemplate<class T> 1399*0b57cec5SDimitry Andric constexpr const T& clamp(const T& v, const T& lo, const T& hi); // C++17 1400*0b57cec5SDimitry Andric 1401*0b57cec5SDimitry Andrictemplate<class T, class Compare> 1402*0b57cec5SDimitry Andric constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17 1403*0b57cec5SDimitry Andric 1404*0b57cec5SDimitry Andrictemplate <class ForwardIterator> 1405e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1406e8d8bef9SDimitry Andric max_element(ForwardIterator first, ForwardIterator last); 1407*0b57cec5SDimitry Andric 1408*0b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1409e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1410e8d8bef9SDimitry Andric max_element(ForwardIterator first, ForwardIterator last, Compare comp); 1411*0b57cec5SDimitry Andric 1412*0b57cec5SDimitry Andrictemplate <class T> 1413e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1414e8d8bef9SDimitry Andric max(const T& a, const T& b); 1415*0b57cec5SDimitry Andric 1416*0b57cec5SDimitry Andrictemplate <class T, class Compare> 1417e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1418e8d8bef9SDimitry Andric max(const T& a, const T& b, Compare comp); 1419*0b57cec5SDimitry Andric 1420*0b57cec5SDimitry Andrictemplate<class T> 1421e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1422e8d8bef9SDimitry Andric max(initializer_list<T> t); 1423*0b57cec5SDimitry Andric 1424*0b57cec5SDimitry Andrictemplate<class T, class Compare> 1425e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1426e8d8bef9SDimitry Andric max(initializer_list<T> t, Compare comp); 1427*0b57cec5SDimitry Andric 1428*0b57cec5SDimitry Andrictemplate<class ForwardIterator> 1429e8d8bef9SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14 1430e8d8bef9SDimitry Andric minmax_element(ForwardIterator first, ForwardIterator last); 1431*0b57cec5SDimitry Andric 1432*0b57cec5SDimitry Andrictemplate<class ForwardIterator, class Compare> 1433e8d8bef9SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14 1434e8d8bef9SDimitry Andric minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); 1435*0b57cec5SDimitry Andric 1436*0b57cec5SDimitry Andrictemplate<class T> 1437e8d8bef9SDimitry Andric constexpr pair<const T&, const T&> // constexpr in C++14 1438e8d8bef9SDimitry Andric minmax(const T& a, const T& b); 1439*0b57cec5SDimitry Andric 1440*0b57cec5SDimitry Andrictemplate<class T, class Compare> 1441e8d8bef9SDimitry Andric constexpr pair<const T&, const T&> // constexpr in C++14 1442e8d8bef9SDimitry Andric minmax(const T& a, const T& b, Compare comp); 1443*0b57cec5SDimitry Andric 1444*0b57cec5SDimitry Andrictemplate<class T> 1445e8d8bef9SDimitry Andric constexpr pair<T, T> // constexpr in C++14 1446e8d8bef9SDimitry Andric minmax(initializer_list<T> t); 1447*0b57cec5SDimitry Andric 1448*0b57cec5SDimitry Andrictemplate<class T, class Compare> 1449e8d8bef9SDimitry Andric constexpr pair<T, T> // constexpr in C++14 1450e8d8bef9SDimitry Andric minmax(initializer_list<T> t, Compare comp); 1451*0b57cec5SDimitry Andric 1452*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 1453*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1454*0b57cec5SDimitry Andric lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 1455*0b57cec5SDimitry Andric 1456*0b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class Compare> 1457*0b57cec5SDimitry Andric constexpr bool // constexpr in C++20 1458*0b57cec5SDimitry Andric lexicographical_compare(InputIterator1 first1, InputIterator1 last1, 1459*0b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, Compare comp); 1460*0b57cec5SDimitry Andric 1461*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 1462e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 1463*0b57cec5SDimitry Andric next_permutation(BidirectionalIterator first, BidirectionalIterator last); 1464*0b57cec5SDimitry Andric 1465*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Compare> 1466e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 1467*0b57cec5SDimitry Andric next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 1468*0b57cec5SDimitry Andric 1469*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 1470e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 1471*0b57cec5SDimitry Andric prev_permutation(BidirectionalIterator first, BidirectionalIterator last); 1472*0b57cec5SDimitry Andric 1473*0b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Compare> 1474e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 1475*0b57cec5SDimitry Andric prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 1476*0b57cec5SDimitry Andric} // std 1477*0b57cec5SDimitry Andric 1478*0b57cec5SDimitry Andric*/ 1479*0b57cec5SDimitry Andric 148081ad6265SDimitry Andric#include <__assert> // all public C++ headers provide the assertion handler 148181ad6265SDimitry Andric#include <__bits> 1482*0b57cec5SDimitry Andric#include <__config> 1483fe6060f1SDimitry Andric#include <__debug> 1484fe6060f1SDimitry Andric#include <cstddef> 1485*0b57cec5SDimitry Andric#include <cstring> 1486fe6060f1SDimitry Andric#include <memory> 1487fe6060f1SDimitry Andric#include <type_traits> 1488*0b57cec5SDimitry Andric#include <version> 1489*0b57cec5SDimitry Andric 1490fe6060f1SDimitry Andric#include <__algorithm/adjacent_find.h> 1491fe6060f1SDimitry Andric#include <__algorithm/all_of.h> 1492fe6060f1SDimitry Andric#include <__algorithm/any_of.h> 1493fe6060f1SDimitry Andric#include <__algorithm/binary_search.h> 1494fe6060f1SDimitry Andric#include <__algorithm/clamp.h> 1495fe6060f1SDimitry Andric#include <__algorithm/comp.h> 1496fe6060f1SDimitry Andric#include <__algorithm/comp_ref_type.h> 1497fe6060f1SDimitry Andric#include <__algorithm/copy.h> 1498fe6060f1SDimitry Andric#include <__algorithm/copy_backward.h> 1499fe6060f1SDimitry Andric#include <__algorithm/copy_if.h> 1500fe6060f1SDimitry Andric#include <__algorithm/copy_n.h> 1501fe6060f1SDimitry Andric#include <__algorithm/count.h> 1502fe6060f1SDimitry Andric#include <__algorithm/count_if.h> 1503fe6060f1SDimitry Andric#include <__algorithm/equal.h> 1504fe6060f1SDimitry Andric#include <__algorithm/equal_range.h> 1505fe6060f1SDimitry Andric#include <__algorithm/fill.h> 150604eeddc0SDimitry Andric#include <__algorithm/fill_n.h> 1507fe6060f1SDimitry Andric#include <__algorithm/find.h> 1508fe6060f1SDimitry Andric#include <__algorithm/find_end.h> 1509fe6060f1SDimitry Andric#include <__algorithm/find_first_of.h> 1510fe6060f1SDimitry Andric#include <__algorithm/find_if.h> 1511fe6060f1SDimitry Andric#include <__algorithm/find_if_not.h> 1512fe6060f1SDimitry Andric#include <__algorithm/for_each.h> 1513fe6060f1SDimitry Andric#include <__algorithm/for_each_n.h> 1514fe6060f1SDimitry Andric#include <__algorithm/generate.h> 151504eeddc0SDimitry Andric#include <__algorithm/generate_n.h> 1516fe6060f1SDimitry Andric#include <__algorithm/half_positive.h> 151781ad6265SDimitry Andric#include <__algorithm/in_found_result.h> 151881ad6265SDimitry Andric#include <__algorithm/in_fun_result.h> 15191fd87a68SDimitry Andric#include <__algorithm/in_in_out_result.h> 152004eeddc0SDimitry Andric#include <__algorithm/in_in_result.h> 152181ad6265SDimitry Andric#include <__algorithm/in_out_out_result.h> 152204eeddc0SDimitry Andric#include <__algorithm/in_out_result.h> 1523fe6060f1SDimitry Andric#include <__algorithm/includes.h> 1524fe6060f1SDimitry Andric#include <__algorithm/inplace_merge.h> 1525fe6060f1SDimitry Andric#include <__algorithm/is_heap.h> 1526fe6060f1SDimitry Andric#include <__algorithm/is_heap_until.h> 1527fe6060f1SDimitry Andric#include <__algorithm/is_partitioned.h> 1528fe6060f1SDimitry Andric#include <__algorithm/is_permutation.h> 1529fe6060f1SDimitry Andric#include <__algorithm/is_sorted.h> 1530fe6060f1SDimitry Andric#include <__algorithm/is_sorted_until.h> 1531fe6060f1SDimitry Andric#include <__algorithm/iter_swap.h> 1532fe6060f1SDimitry Andric#include <__algorithm/lexicographical_compare.h> 1533fe6060f1SDimitry Andric#include <__algorithm/lower_bound.h> 1534fe6060f1SDimitry Andric#include <__algorithm/make_heap.h> 1535fe6060f1SDimitry Andric#include <__algorithm/max.h> 1536fe6060f1SDimitry Andric#include <__algorithm/max_element.h> 1537fe6060f1SDimitry Andric#include <__algorithm/merge.h> 1538fe6060f1SDimitry Andric#include <__algorithm/min.h> 1539fe6060f1SDimitry Andric#include <__algorithm/min_element.h> 154081ad6265SDimitry Andric#include <__algorithm/min_max_result.h> 1541fe6060f1SDimitry Andric#include <__algorithm/minmax.h> 1542fe6060f1SDimitry Andric#include <__algorithm/minmax_element.h> 1543fe6060f1SDimitry Andric#include <__algorithm/mismatch.h> 1544fe6060f1SDimitry Andric#include <__algorithm/move.h> 1545fe6060f1SDimitry Andric#include <__algorithm/move_backward.h> 1546fe6060f1SDimitry Andric#include <__algorithm/next_permutation.h> 1547fe6060f1SDimitry Andric#include <__algorithm/none_of.h> 1548fe6060f1SDimitry Andric#include <__algorithm/nth_element.h> 1549fe6060f1SDimitry Andric#include <__algorithm/partial_sort.h> 1550fe6060f1SDimitry Andric#include <__algorithm/partial_sort_copy.h> 1551fe6060f1SDimitry Andric#include <__algorithm/partition.h> 1552fe6060f1SDimitry Andric#include <__algorithm/partition_copy.h> 1553fe6060f1SDimitry Andric#include <__algorithm/partition_point.h> 1554fe6060f1SDimitry Andric#include <__algorithm/pop_heap.h> 1555fe6060f1SDimitry Andric#include <__algorithm/prev_permutation.h> 1556fe6060f1SDimitry Andric#include <__algorithm/push_heap.h> 155781ad6265SDimitry Andric#include <__algorithm/ranges_adjacent_find.h> 155881ad6265SDimitry Andric#include <__algorithm/ranges_all_of.h> 155981ad6265SDimitry Andric#include <__algorithm/ranges_any_of.h> 156081ad6265SDimitry Andric#include <__algorithm/ranges_binary_search.h> 156181ad6265SDimitry Andric#include <__algorithm/ranges_copy.h> 156281ad6265SDimitry Andric#include <__algorithm/ranges_copy_backward.h> 156381ad6265SDimitry Andric#include <__algorithm/ranges_copy_if.h> 156481ad6265SDimitry Andric#include <__algorithm/ranges_copy_n.h> 156581ad6265SDimitry Andric#include <__algorithm/ranges_count.h> 156681ad6265SDimitry Andric#include <__algorithm/ranges_count_if.h> 156781ad6265SDimitry Andric#include <__algorithm/ranges_equal.h> 1568fcaf7f86SDimitry Andric#include <__algorithm/ranges_equal_range.h> 156981ad6265SDimitry Andric#include <__algorithm/ranges_fill.h> 157081ad6265SDimitry Andric#include <__algorithm/ranges_fill_n.h> 157181ad6265SDimitry Andric#include <__algorithm/ranges_find.h> 1572753f127fSDimitry Andric#include <__algorithm/ranges_find_end.h> 157381ad6265SDimitry Andric#include <__algorithm/ranges_find_first_of.h> 157481ad6265SDimitry Andric#include <__algorithm/ranges_find_if.h> 157581ad6265SDimitry Andric#include <__algorithm/ranges_find_if_not.h> 157681ad6265SDimitry Andric#include <__algorithm/ranges_for_each.h> 157781ad6265SDimitry Andric#include <__algorithm/ranges_for_each_n.h> 1578fcaf7f86SDimitry Andric#include <__algorithm/ranges_includes.h> 157981ad6265SDimitry Andric#include <__algorithm/ranges_is_partitioned.h> 158081ad6265SDimitry Andric#include <__algorithm/ranges_is_sorted.h> 158181ad6265SDimitry Andric#include <__algorithm/ranges_is_sorted_until.h> 158281ad6265SDimitry Andric#include <__algorithm/ranges_lexicographical_compare.h> 158381ad6265SDimitry Andric#include <__algorithm/ranges_lower_bound.h> 1584753f127fSDimitry Andric#include <__algorithm/ranges_make_heap.h> 158581ad6265SDimitry Andric#include <__algorithm/ranges_max.h> 158681ad6265SDimitry Andric#include <__algorithm/ranges_max_element.h> 1587753f127fSDimitry Andric#include <__algorithm/ranges_merge.h> 158881ad6265SDimitry Andric#include <__algorithm/ranges_min.h> 158981ad6265SDimitry Andric#include <__algorithm/ranges_min_element.h> 159081ad6265SDimitry Andric#include <__algorithm/ranges_minmax.h> 159181ad6265SDimitry Andric#include <__algorithm/ranges_minmax_element.h> 159281ad6265SDimitry Andric#include <__algorithm/ranges_mismatch.h> 159381ad6265SDimitry Andric#include <__algorithm/ranges_move.h> 159481ad6265SDimitry Andric#include <__algorithm/ranges_move_backward.h> 159581ad6265SDimitry Andric#include <__algorithm/ranges_none_of.h> 1596753f127fSDimitry Andric#include <__algorithm/ranges_nth_element.h> 1597fcaf7f86SDimitry Andric#include <__algorithm/ranges_partial_sort.h> 1598fcaf7f86SDimitry Andric#include <__algorithm/ranges_partition.h> 1599fcaf7f86SDimitry Andric#include <__algorithm/ranges_partition_copy.h> 1600fcaf7f86SDimitry Andric#include <__algorithm/ranges_partition_point.h> 1601753f127fSDimitry Andric#include <__algorithm/ranges_pop_heap.h> 1602753f127fSDimitry Andric#include <__algorithm/ranges_push_heap.h> 1603753f127fSDimitry Andric#include <__algorithm/ranges_remove.h> 1604753f127fSDimitry Andric#include <__algorithm/ranges_remove_if.h> 160581ad6265SDimitry Andric#include <__algorithm/ranges_replace.h> 160681ad6265SDimitry Andric#include <__algorithm/ranges_replace_if.h> 160781ad6265SDimitry Andric#include <__algorithm/ranges_reverse.h> 1608753f127fSDimitry Andric#include <__algorithm/ranges_reverse_copy.h> 1609753f127fSDimitry Andric#include <__algorithm/ranges_rotate_copy.h> 1610753f127fSDimitry Andric#include <__algorithm/ranges_search.h> 1611753f127fSDimitry Andric#include <__algorithm/ranges_search_n.h> 1612753f127fSDimitry Andric#include <__algorithm/ranges_set_difference.h> 1613753f127fSDimitry Andric#include <__algorithm/ranges_set_intersection.h> 1614753f127fSDimitry Andric#include <__algorithm/ranges_set_symmetric_difference.h> 1615fcaf7f86SDimitry Andric#include <__algorithm/ranges_set_union.h> 1616fcaf7f86SDimitry Andric#include <__algorithm/ranges_shuffle.h> 161781ad6265SDimitry Andric#include <__algorithm/ranges_sort.h> 1618753f127fSDimitry Andric#include <__algorithm/ranges_sort_heap.h> 1619fcaf7f86SDimitry Andric#include <__algorithm/ranges_stable_partition.h> 162081ad6265SDimitry Andric#include <__algorithm/ranges_stable_sort.h> 162181ad6265SDimitry Andric#include <__algorithm/ranges_swap_ranges.h> 162281ad6265SDimitry Andric#include <__algorithm/ranges_transform.h> 162381ad6265SDimitry Andric#include <__algorithm/ranges_upper_bound.h> 1624fe6060f1SDimitry Andric#include <__algorithm/remove.h> 1625fe6060f1SDimitry Andric#include <__algorithm/remove_copy.h> 1626fe6060f1SDimitry Andric#include <__algorithm/remove_copy_if.h> 1627fe6060f1SDimitry Andric#include <__algorithm/remove_if.h> 1628fe6060f1SDimitry Andric#include <__algorithm/replace.h> 1629fe6060f1SDimitry Andric#include <__algorithm/replace_copy.h> 1630fe6060f1SDimitry Andric#include <__algorithm/replace_copy_if.h> 1631fe6060f1SDimitry Andric#include <__algorithm/replace_if.h> 1632fe6060f1SDimitry Andric#include <__algorithm/reverse.h> 1633fe6060f1SDimitry Andric#include <__algorithm/reverse_copy.h> 1634fe6060f1SDimitry Andric#include <__algorithm/rotate.h> 1635fe6060f1SDimitry Andric#include <__algorithm/rotate_copy.h> 1636fe6060f1SDimitry Andric#include <__algorithm/sample.h> 1637fe6060f1SDimitry Andric#include <__algorithm/search.h> 1638fe6060f1SDimitry Andric#include <__algorithm/search_n.h> 1639fe6060f1SDimitry Andric#include <__algorithm/set_difference.h> 1640fe6060f1SDimitry Andric#include <__algorithm/set_intersection.h> 1641fe6060f1SDimitry Andric#include <__algorithm/set_symmetric_difference.h> 1642fe6060f1SDimitry Andric#include <__algorithm/set_union.h> 1643fe6060f1SDimitry Andric#include <__algorithm/shift_left.h> 1644fe6060f1SDimitry Andric#include <__algorithm/shift_right.h> 1645fe6060f1SDimitry Andric#include <__algorithm/shuffle.h> 1646fe6060f1SDimitry Andric#include <__algorithm/sift_down.h> 1647fe6060f1SDimitry Andric#include <__algorithm/sort.h> 1648fe6060f1SDimitry Andric#include <__algorithm/sort_heap.h> 1649fe6060f1SDimitry Andric#include <__algorithm/stable_partition.h> 1650fe6060f1SDimitry Andric#include <__algorithm/stable_sort.h> 1651fe6060f1SDimitry Andric#include <__algorithm/swap_ranges.h> 1652fe6060f1SDimitry Andric#include <__algorithm/transform.h> 1653fe6060f1SDimitry Andric#include <__algorithm/unique.h> 165404eeddc0SDimitry Andric#include <__algorithm/unique_copy.h> 1655fe6060f1SDimitry Andric#include <__algorithm/unwrap_iter.h> 1656fe6060f1SDimitry Andric#include <__algorithm/upper_bound.h> 1657*0b57cec5SDimitry Andric 165881ad6265SDimitry Andric#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES 165981ad6265SDimitry Andric# include <chrono> 166081ad6265SDimitry Andric# include <iterator> 166181ad6265SDimitry Andric# include <utility> 166281ad6265SDimitry Andric#endif 166381ad6265SDimitry Andric 166481ad6265SDimitry Andric// standard-mandated includes 166581ad6265SDimitry Andric#include <initializer_list> 166681ad6265SDimitry Andric 1667*0b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 1668*0b57cec5SDimitry Andric# pragma GCC system_header 1669*0b57cec5SDimitry Andric#endif 1670*0b57cec5SDimitry Andric 1671e40139ffSDimitry Andric#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17 1672e40139ffSDimitry Andric# include <__pstl_algorithm> 1673e40139ffSDimitry Andric#endif 1674e40139ffSDimitry Andric 1675*0b57cec5SDimitry Andric#endif // _LIBCPP_ALGORITHM 1676