10b57cec5SDimitry Andric// -*- C++ -*- 2349cc55cSDimitry Andric//===----------------------------------------------------------------------===// 30b57cec5SDimitry Andric// 40b57cec5SDimitry Andric// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 50b57cec5SDimitry Andric// See https://llvm.org/LICENSE.txt for license information. 60b57cec5SDimitry Andric// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 70b57cec5SDimitry Andric// 80b57cec5SDimitry Andric//===----------------------------------------------------------------------===// 90b57cec5SDimitry Andric 100b57cec5SDimitry Andric#ifndef _LIBCPP_ALGORITHM 110b57cec5SDimitry Andric#define _LIBCPP_ALGORITHM 120b57cec5SDimitry Andric 130b57cec5SDimitry Andric/* 140b57cec5SDimitry Andric algorithm synopsis 150b57cec5SDimitry Andric 160b57cec5SDimitry Andric#include <initializer_list> 170b57cec5SDimitry Andric 180b57cec5SDimitry Andricnamespace std 190b57cec5SDimitry Andric{ 200b57cec5SDimitry 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 290*753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 291*753f127fSDimitry Andric class Proj = identity> 292*753f127fSDimitry Andric requires sortable<I, Comp, Proj> 293*753f127fSDimitry Andric constexpr I 294*753f127fSDimitry Andric ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 295*753f127fSDimitry Andric 296*753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 297*753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 298*753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 299*753f127fSDimitry Andric ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 300*753f127fSDimitry Andric 301*753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 302*753f127fSDimitry Andric class Proj = identity> 303*753f127fSDimitry Andric requires sortable<I, Comp, Proj> 304*753f127fSDimitry Andric constexpr I 305*753f127fSDimitry Andric ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 306*753f127fSDimitry Andric 307*753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 308*753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 309*753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 310*753f127fSDimitry Andric ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 311*753f127fSDimitry Andric 312*753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 313*753f127fSDimitry Andric class Proj = identity> 314*753f127fSDimitry Andric requires sortable<I, Comp, Proj> 315*753f127fSDimitry Andric constexpr I 316*753f127fSDimitry Andric ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 317*753f127fSDimitry Andric 318*753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 319*753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 320*753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 321*753f127fSDimitry Andric ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 322*753f127fSDimitry Andric 323*753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 324*753f127fSDimitry Andric class Proj = identity> 325*753f127fSDimitry Andric requires sortable<I, Comp, Proj> 326*753f127fSDimitry Andric constexpr I 327*753f127fSDimitry Andric ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 328*753f127fSDimitry Andric 329*753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 330*753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 331*753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 332*753f127fSDimitry Andric ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 333*753f127fSDimitry 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 36381ad6265SDimitry Andric template<class T, output_iterator<const T&> O, sentinel_for<O> S> 36481ad6265SDimitry Andric constexpr O ranges::fill(O first, S last, const T& value); // since C++20 36581ad6265SDimitry Andric 36681ad6265SDimitry Andric template<class T, output_range<const T&> R> 36781ad6265SDimitry Andric constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value); // since C++20 36881ad6265SDimitry Andric 36981ad6265SDimitry Andric template<class T, output_iterator<const T&> O> 37081ad6265SDimitry Andric constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value); // since C++20 37181ad6265SDimitry Andric 37281ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 37381ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 37481ad6265SDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 37581ad6265SDimitry Andric constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2, 37681ad6265SDimitry Andric Pred pred = {}, 37781ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 37881ad6265SDimitry Andric 37981ad6265SDimitry Andric template<input_range R1, input_range R2, class Pred = ranges::equal_to, 38081ad6265SDimitry Andric class Proj1 = identity, class Proj2 = identity> 38181ad6265SDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 38281ad6265SDimitry Andric constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {}, 38381ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 38481ad6265SDimitry Andric 38581ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 38681ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 38781ad6265SDimitry Andric constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {}); // since C++20 38881ad6265SDimitry Andric 38981ad6265SDimitry Andric template<input_range R, class Proj = identity, 39081ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 39181ad6265SDimitry Andric constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {}); // since C++20 39281ad6265SDimitry Andric 39381ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 39481ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 39581ad6265SDimitry Andric constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {}); // since C++20 39681ad6265SDimitry Andric 39781ad6265SDimitry Andric template<input_range R, class Proj = identity, 39881ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 39981ad6265SDimitry Andric constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {}); // since C++20 40081ad6265SDimitry Andric 40181ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class Proj = identity, 40281ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 40381ad6265SDimitry Andric constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {}); // since C++20 40481ad6265SDimitry Andric 40581ad6265SDimitry Andric template<input_range R, class Proj = identity, 40681ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 40781ad6265SDimitry Andric constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {}); // since C++20 40881ad6265SDimitry Andric 40981ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 41081ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> 41181ad6265SDimitry Andric constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 41281ad6265SDimitry Andric 41381ad6265SDimitry Andric template<forward_range R, class Proj = identity, 41481ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 41581ad6265SDimitry Andric constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 41681ad6265SDimitry Andric 41781ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 41881ad6265SDimitry Andric indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> 41981ad6265SDimitry Andric constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20 42081ad6265SDimitry Andric 42181ad6265SDimitry Andric template<forward_range R, class Proj = identity, 42281ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> 42381ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 42481ad6265SDimitry Andric ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // since C++20 42581ad6265SDimitry Andric 426*753f127fSDimitry Andric template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less, 427*753f127fSDimitry Andric class Proj = identity> 428*753f127fSDimitry Andric requires sortable<I, Comp, Proj> 429*753f127fSDimitry Andric constexpr I 430*753f127fSDimitry Andric ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {}); // since C++20 431*753f127fSDimitry Andric 432*753f127fSDimitry Andric template<random_access_range R, class Comp = ranges::less, class Proj = identity> 433*753f127fSDimitry Andric requires sortable<iterator_t<R>, Comp, Proj> 434*753f127fSDimitry Andric constexpr borrowed_iterator_t<R> 435*753f127fSDimitry Andric ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {}); // since C++20 436*753f127fSDimitry Andric 43781ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 43881ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 43981ad6265SDimitry Andric constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 44081ad6265SDimitry Andric 44181ad6265SDimitry Andric template<forward_range R, class T, class Proj = identity, 44281ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp = 44381ad6265SDimitry Andric ranges::less> 44481ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 44581ad6265SDimitry Andric upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 44681ad6265SDimitry Andric 44781ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 44881ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 44981ad6265SDimitry Andric constexpr I lower_bound(I first, S last, const T& value, Comp comp = {}, 45081ad6265SDimitry Andric Proj proj = {}); // since C++20 45181ad6265SDimitry Andric template<forward_range R, class T, class Proj = identity, 45281ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp = 45381ad6265SDimitry Andric ranges::less> 45481ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 45581ad6265SDimitry Andric lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {}); // since C++20 45681ad6265SDimitry Andric 45781ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity, 45881ad6265SDimitry Andric indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> 45981ad6265SDimitry Andric constexpr bool binary_search(I first, S last, const T& value, Comp comp = {}, 46081ad6265SDimitry Andric Proj proj = {}); // since C++20 46181ad6265SDimitry Andric 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 bool binary_search(R&& r, const T& value, Comp comp = {}, 46681ad6265SDimitry Andric Proj proj = {}); // since C++20 46781ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2, 46881ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 46981ad6265SDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 47081ad6265SDimitry Andric constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, 47181ad6265SDimitry Andric Pred pred = {}, 47281ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 47381ad6265SDimitry Andric 47481ad6265SDimitry Andric template<input_range R1, forward_range R2, 47581ad6265SDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 47681ad6265SDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 47781ad6265SDimitry Andric constexpr borrowed_iterator_t<R1> 47881ad6265SDimitry Andric ranges::find_first_of(R1&& r1, R2&& r2, 47981ad6265SDimitry Andric Pred pred = {}, 48081ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 48181ad6265SDimitry Andric 48281ad6265SDimitry Andric template<forward_iterator I, sentinel_for<I> S, class Proj = identity, 48381ad6265SDimitry Andric indirect_binary_predicate<projected<I, Proj>, 48481ad6265SDimitry Andric projected<I, Proj>> Pred = ranges::equal_to> 48581ad6265SDimitry Andric constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {}); // since C+20 48681ad6265SDimitry Andric 48781ad6265SDimitry Andric template<forward_range R, class Proj = identity, 48881ad6265SDimitry Andric indirect_binary_predicate<projected<iterator_t<R>, Proj>, 48981ad6265SDimitry Andric projected<iterator_t<R>, Proj>> Pred = ranges::equal_to> 49081ad6265SDimitry Andric constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // since C++20 49181ad6265SDimitry Andric 49281ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity> 49381ad6265SDimitry Andric requires indirectly_writable<I, const T2&> && 49481ad6265SDimitry Andric indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> 49581ad6265SDimitry Andric constexpr I 49681ad6265SDimitry Andric ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20 49781ad6265SDimitry Andric 49881ad6265SDimitry Andric template<input_range R, class T1, class T2, class Proj = identity> 49981ad6265SDimitry Andric requires indirectly_writable<iterator_t<R>, const T2&> && 50081ad6265SDimitry Andric indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*> 50181ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 50281ad6265SDimitry Andric ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20 50381ad6265SDimitry Andric 50481ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity, 50581ad6265SDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 50681ad6265SDimitry Andric requires indirectly_writable<I, const T&> 50781ad6265SDimitry Andric constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20 50881ad6265SDimitry Andric 50981ad6265SDimitry Andric template<input_range R, class T, class Proj = identity, 51081ad6265SDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 51181ad6265SDimitry Andric requires indirectly_writable<iterator_t<R>, const T&> 51281ad6265SDimitry Andric constexpr borrowed_iterator_t<R> 51381ad6265SDimitry Andric ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {}); // since C++20 51481ad6265SDimitry Andric 51581ad6265SDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 51681ad6265SDimitry Andric class Proj1 = identity, class Proj2 = identity, 51781ad6265SDimitry Andric indirect_strict_weak_order<projected<I1, Proj1>, 51881ad6265SDimitry Andric projected<I2, Proj2>> Comp = ranges::less> 51981ad6265SDimitry Andric constexpr bool 52081ad6265SDimitry Andric ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2, 52181ad6265SDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 52281ad6265SDimitry Andric 52381ad6265SDimitry Andric template<input_range R1, input_range R2, class Proj1 = identity, 52481ad6265SDimitry Andric class Proj2 = identity, 52581ad6265SDimitry Andric indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>, 52681ad6265SDimitry Andric projected<iterator_t<R2>, Proj2>> Comp = ranges::less> 52781ad6265SDimitry Andric constexpr bool 52881ad6265SDimitry Andric ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {}, 52981ad6265SDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 53081ad6265SDimitry Andric 53181ad6265SDimitry Andric template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2> 53281ad6265SDimitry Andric requires indirectly_movable<I1, I2> 53381ad6265SDimitry Andric constexpr ranges::move_backward_result<I1, I2> 53481ad6265SDimitry Andric ranges::move_backward(I1 first, S1 last, I2 result); // since C++20 53581ad6265SDimitry Andric 53681ad6265SDimitry Andric template<bidirectional_range R, bidirectional_iterator I> 53781ad6265SDimitry Andric requires indirectly_movable<iterator_t<R>, I> 53881ad6265SDimitry Andric constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I> 53981ad6265SDimitry Andric ranges::move_backward(R&& r, I result); // since C++20 54081ad6265SDimitry Andric 54181ad6265SDimitry Andric template<input_iterator I, sentinel_for<I> S, weakly_incrementable O> 54281ad6265SDimitry Andric requires indirectly_movable<I, O> 54381ad6265SDimitry Andric constexpr ranges::move_result<I, O> 54481ad6265SDimitry Andric ranges::move(I first, S last, O result); // since C++20 54581ad6265SDimitry Andric 54681ad6265SDimitry Andric template<input_range R, weakly_incrementable O> 54781ad6265SDimitry Andric requires indirectly_movable<iterator_t<R>, O> 54881ad6265SDimitry Andric constexpr ranges::move_result<borrowed_iterator_t<R>, O> 54981ad6265SDimitry Andric ranges::move(R&& r, O result); // since C++20 55081ad6265SDimitry Andric 551*753f127fSDimitry Andric template<class I1, class I2, class O> 552*753f127fSDimitry Andric using merge_result = in_in_out_result<I1, I2, O>; // since C++20 553*753f127fSDimitry Andric 554*753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 555*753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity, 556*753f127fSDimitry Andric class Proj2 = identity> 557*753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 558*753f127fSDimitry Andric constexpr merge_result<I1, I2, O> 559*753f127fSDimitry Andric merge(I1 first1, S1 last1, I2 first2, S2 last2, O result, 560*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 561*753f127fSDimitry Andric 562*753f127fSDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less, 563*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 564*753f127fSDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 565*753f127fSDimitry Andric constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> 566*753f127fSDimitry Andric merge(R1&& r1, R2&& r2, O result, 567*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 568*753f127fSDimitry Andric 569*753f127fSDimitry Andric template<permutable I, sentinel_for<I> S, class T, class Proj = identity> 570*753f127fSDimitry Andric requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*> 571*753f127fSDimitry Andric constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {}); // since C++20 572*753f127fSDimitry Andric 573*753f127fSDimitry Andric template<forward_range R, class T, class Proj = identity> 574*753f127fSDimitry Andric requires permutable<iterator_t<R>> && 575*753f127fSDimitry Andric indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*> 576*753f127fSDimitry Andric constexpr borrowed_subrange_t<R> 577*753f127fSDimitry Andric ranges::remove(R&& r, const T& value, Proj proj = {}); // since C++20 578*753f127fSDimitry Andric 579*753f127fSDimitry Andric template<permutable I, sentinel_for<I> S, class Proj = identity, 580*753f127fSDimitry Andric indirect_unary_predicate<projected<I, Proj>> Pred> 581*753f127fSDimitry Andric constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {}); // since C++20 582*753f127fSDimitry Andric 583*753f127fSDimitry Andric template<forward_range R, class Proj = identity, 584*753f127fSDimitry Andric indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred> 585*753f127fSDimitry Andric requires permutable<iterator_t<R>> 586*753f127fSDimitry Andric constexpr borrowed_subrange_t<R> 587*753f127fSDimitry Andric ranges::remove_if(R&& r, Pred pred, Proj proj = {}); // since C++20 588*753f127fSDimitry Andric 589*753f127fSDimitry Andric template<class I, class O> 590*753f127fSDimitry Andric using set_difference_result = in_out_result<I, O>; // since C++20 591*753f127fSDimitry Andric 592*753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 593*753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 594*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 595*753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 596*753f127fSDimitry Andric constexpr set_difference_result<I1, O> 597*753f127fSDimitry Andric set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result, 598*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 599*753f127fSDimitry Andric 600*753f127fSDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, 601*753f127fSDimitry Andric class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> 602*753f127fSDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 603*753f127fSDimitry Andric constexpr set_difference_result<borrowed_iterator_t<R1>, O> 604*753f127fSDimitry Andric set_difference(R1&& r1, R2&& r2, O result, 605*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 606*753f127fSDimitry Andric 607*753f127fSDimitry Andric template<class I1, class I2, class O> 608*753f127fSDimitry Andric using set_intersection_result = in_in_out_result<I1, I2, O>; // since C++20 609*753f127fSDimitry Andric 610*753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 611*753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 612*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 613*753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 614*753f127fSDimitry Andric constexpr set_intersection_result<I1, I2, O> 615*753f127fSDimitry Andric set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result, 616*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 617*753f127fSDimitry Andric 618*753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 619*753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 620*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 621*753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 622*753f127fSDimitry Andric constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> 623*753f127fSDimitry Andric set_intersection(R1&& r1, R2&& r2, O result, 624*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 625*753f127fSDimitry Andric 626*753f127fSDimitry Andric template <class _InIter, class _OutIter> 627*753f127fSDimitry Andric using reverse_copy_result = in_out_result<_InIter, _OutIter>; // since C++20 628*753f127fSDimitry Andric 629*753f127fSDimitry Andric template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O> 630*753f127fSDimitry Andric requires indirectly_copyable<I, O> 631*753f127fSDimitry Andric constexpr ranges::reverse_copy_result<I, O> 632*753f127fSDimitry Andric ranges::reverse_copy(I first, S last, O result); // since C++20 633*753f127fSDimitry Andric 634*753f127fSDimitry Andric template<bidirectional_range R, weakly_incrementable O> 635*753f127fSDimitry Andric requires indirectly_copyable<iterator_t<R>, O> 636*753f127fSDimitry Andric constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O> 637*753f127fSDimitry Andric ranges::reverse_copy(R&& r, O result); // since C++20 638*753f127fSDimitry Andric 639*753f127fSDimitry Andric template <class _InIter, class _OutIter> 640*753f127fSDimitry Andric using rotate_copy_result = in_out_result<_InIter, _OutIter>; // since C++20 641*753f127fSDimitry Andric 642*753f127fSDimitry Andric template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O> 643*753f127fSDimitry Andric requires indirectly_copyable<I, O> 644*753f127fSDimitry Andric constexpr ranges::rotate_copy_result<I, O> 645*753f127fSDimitry Andric ranges::rotate_copy(I first, I middle, S last, O result); // since C++20 646*753f127fSDimitry Andric 647*753f127fSDimitry Andric template<forward_range R, weakly_incrementable O> 648*753f127fSDimitry Andric requires indirectly_copyable<iterator_t<R>, O> 649*753f127fSDimitry Andric constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O> 650*753f127fSDimitry Andric ranges::rotate_copy(R&& r, iterator_t<R> middle, O result); // since C++20 651*753f127fSDimitry Andric 652*753f127fSDimitry Andric template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, 653*753f127fSDimitry Andric sentinel_for<I2> S2, class Pred = ranges::equal_to, 654*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 655*753f127fSDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 656*753f127fSDimitry Andric constexpr subrange<I1> 657*753f127fSDimitry Andric ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, 658*753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 659*753f127fSDimitry Andric 660*753f127fSDimitry Andric template<forward_range R1, forward_range R2, class Pred = ranges::equal_to, 661*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 662*753f127fSDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 663*753f127fSDimitry Andric constexpr borrowed_subrange_t<R1> 664*753f127fSDimitry Andric ranges::search(R1&& r1, R2&& r2, Pred pred = {}, 665*753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 666*753f127fSDimitry Andric 667*753f127fSDimitry Andric template<forward_iterator I, sentinel_for<I> S, class T, 668*753f127fSDimitry Andric class Pred = ranges::equal_to, class Proj = identity> 669*753f127fSDimitry Andric requires indirectly_comparable<I, const T*, Pred, Proj> 670*753f127fSDimitry Andric constexpr subrange<I> 671*753f127fSDimitry Andric ranges::search_n(I first, S last, iter_difference_t<I> count, 672*753f127fSDimitry Andric const T& value, Pred pred = {}, Proj proj = {}); // since C++20 673*753f127fSDimitry Andric 674*753f127fSDimitry Andric template<forward_range R, class T, class Pred = ranges::equal_to, 675*753f127fSDimitry Andric class Proj = identity> 676*753f127fSDimitry Andric requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj> 677*753f127fSDimitry Andric constexpr borrowed_subrange_t<R> 678*753f127fSDimitry Andric ranges::search_n(R&& r, range_difference_t<R> count, 679*753f127fSDimitry Andric const T& value, Pred pred = {}, Proj proj = {}); // since C++20 680*753f127fSDimitry Andric 681*753f127fSDimitry Andric template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2, 682*753f127fSDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 683*753f127fSDimitry Andric requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 684*753f127fSDimitry Andric constexpr subrange<I1> 685*753f127fSDimitry Andric ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, 686*753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 687*753f127fSDimitry Andric 688*753f127fSDimitry Andric template<forward_range R1, forward_range R2, 689*753f127fSDimitry Andric class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 690*753f127fSDimitry Andric requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 691*753f127fSDimitry Andric constexpr borrowed_subrange_t<R1> 692*753f127fSDimitry Andric ranges::find_end(R1&& r1, R2&& r2, Pred pred = {}, 693*753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 694*753f127fSDimitry Andric 695*753f127fSDimitry Andric template<class I1, class I2, class O> 696*753f127fSDimitry Andric using set_symmetric_difference_result = in_in_out_result<I1, I2, O>; // since C++20 697*753f127fSDimitry Andric 698*753f127fSDimitry Andric template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2, 699*753f127fSDimitry Andric weakly_incrementable O, class Comp = ranges::less, 700*753f127fSDimitry Andric class Proj1 = identity, class Proj2 = identity> 701*753f127fSDimitry Andric requires mergeable<I1, I2, O, Comp, Proj1, Proj2> 702*753f127fSDimitry Andric constexpr set_symmetric_difference_result<I1, I2, O> 703*753f127fSDimitry Andric set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result, 704*753f127fSDimitry Andric Comp comp = {}, Proj1 proj1 = {}, 705*753f127fSDimitry Andric Proj2 proj2 = {}); // since C++20 706*753f127fSDimitry Andric 707*753f127fSDimitry Andric template<input_range R1, input_range R2, weakly_incrementable O, 708*753f127fSDimitry Andric class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity> 709*753f127fSDimitry Andric requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2> 710*753f127fSDimitry Andric constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>, 711*753f127fSDimitry Andric borrowed_iterator_t<R2>, O> 712*753f127fSDimitry Andric set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {}, 713*753f127fSDimitry Andric Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20 71481ad6265SDimitry Andric 71504eeddc0SDimitry Andric} 71604eeddc0SDimitry Andric 7170b57cec5SDimitry Andric constexpr bool // constexpr in C++20 7180b57cec5SDimitry Andric all_of(InputIterator first, InputIterator last, Predicate pred); 7190b57cec5SDimitry Andric 7200b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 7210b57cec5SDimitry Andric constexpr bool // constexpr in C++20 7220b57cec5SDimitry Andric any_of(InputIterator first, InputIterator last, Predicate pred); 7230b57cec5SDimitry Andric 7240b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 7250b57cec5SDimitry Andric constexpr bool // constexpr in C++20 7260b57cec5SDimitry Andric none_of(InputIterator first, InputIterator last, Predicate pred); 7270b57cec5SDimitry Andric 7280b57cec5SDimitry Andrictemplate <class InputIterator, class Function> 7290b57cec5SDimitry Andric constexpr Function // constexpr in C++20 7300b57cec5SDimitry Andric for_each(InputIterator first, InputIterator last, Function f); 7310b57cec5SDimitry Andric 7320b57cec5SDimitry Andrictemplate<class InputIterator, class Size, class Function> 7330b57cec5SDimitry Andric constexpr InputIterator // constexpr in C++20 7340b57cec5SDimitry Andric for_each_n(InputIterator first, Size n, Function f); // C++17 7350b57cec5SDimitry Andric 7360b57cec5SDimitry Andrictemplate <class InputIterator, class T> 7370b57cec5SDimitry Andric constexpr InputIterator // constexpr in C++20 7380b57cec5SDimitry Andric find(InputIterator first, InputIterator last, const T& value); 7390b57cec5SDimitry Andric 7400b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 7410b57cec5SDimitry Andric constexpr InputIterator // constexpr in C++20 7420b57cec5SDimitry Andric find_if(InputIterator first, InputIterator last, Predicate pred); 7430b57cec5SDimitry Andric 7440b57cec5SDimitry Andrictemplate<class InputIterator, class Predicate> 745e8d8bef9SDimitry Andric constexpr InputIterator // constexpr in C++20 7460b57cec5SDimitry Andric find_if_not(InputIterator first, InputIterator last, Predicate pred); 7470b57cec5SDimitry Andric 7480b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 749e8d8bef9SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 7500b57cec5SDimitry Andric find_end(ForwardIterator1 first1, ForwardIterator1 last1, 7510b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); 7520b57cec5SDimitry Andric 7530b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 754e8d8bef9SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 7550b57cec5SDimitry Andric find_end(ForwardIterator1 first1, ForwardIterator1 last1, 7560b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 7570b57cec5SDimitry Andric 7580b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 7590b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 7600b57cec5SDimitry Andric find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 7610b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); 7620b57cec5SDimitry Andric 7630b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 7640b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 7650b57cec5SDimitry Andric find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, 7660b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 7670b57cec5SDimitry Andric 7680b57cec5SDimitry Andrictemplate <class ForwardIterator> 7690b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 7700b57cec5SDimitry Andric adjacent_find(ForwardIterator first, ForwardIterator last); 7710b57cec5SDimitry Andric 7720b57cec5SDimitry Andrictemplate <class ForwardIterator, class BinaryPredicate> 7730b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 7740b57cec5SDimitry Andric adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 7750b57cec5SDimitry Andric 7760b57cec5SDimitry Andrictemplate <class InputIterator, class T> 7770b57cec5SDimitry Andric constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20 7780b57cec5SDimitry Andric count(InputIterator first, InputIterator last, const T& value); 7790b57cec5SDimitry Andric 7800b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 7810b57cec5SDimitry Andric constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20 7820b57cec5SDimitry Andric count_if(InputIterator first, InputIterator last, Predicate pred); 7830b57cec5SDimitry Andric 7840b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 7850b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 7860b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 7870b57cec5SDimitry Andric 7880b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 7890b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 7900b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, 7910b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2); // **C++14** 7920b57cec5SDimitry Andric 7930b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 7940b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 7950b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, 7960b57cec5SDimitry Andric InputIterator2 first2, BinaryPredicate pred); 7970b57cec5SDimitry Andric 7980b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 7990b57cec5SDimitry Andric constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20 8000b57cec5SDimitry Andric mismatch(InputIterator1 first1, InputIterator1 last1, 8010b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, 8020b57cec5SDimitry Andric BinaryPredicate pred); // **C++14** 8030b57cec5SDimitry Andric 8040b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 8050b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8060b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); 8070b57cec5SDimitry Andric 8080b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 8090b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8100b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, 8110b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2); // **C++14** 8120b57cec5SDimitry Andric 8130b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 8140b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8150b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, 8160b57cec5SDimitry Andric InputIterator2 first2, BinaryPredicate pred); 8170b57cec5SDimitry Andric 8180b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class BinaryPredicate> 8190b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8200b57cec5SDimitry Andric equal(InputIterator1 first1, InputIterator1 last1, 8210b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, 8220b57cec5SDimitry Andric BinaryPredicate pred); // **C++14** 8230b57cec5SDimitry Andric 8240b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2> 8250b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8260b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 8270b57cec5SDimitry Andric ForwardIterator2 first2); 8280b57cec5SDimitry Andric 8290b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2> 8300b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8310b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 8320b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); // **C++14** 8330b57cec5SDimitry Andric 8340b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 8350b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8360b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 8370b57cec5SDimitry Andric ForwardIterator2 first2, BinaryPredicate pred); 8380b57cec5SDimitry Andric 8390b57cec5SDimitry Andrictemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 8400b57cec5SDimitry Andric constexpr bool // constexpr in C++20 8410b57cec5SDimitry Andric is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 8420b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, 8430b57cec5SDimitry Andric BinaryPredicate pred); // **C++14** 8440b57cec5SDimitry Andric 8450b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 8460b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 8470b57cec5SDimitry Andric search(ForwardIterator1 first1, ForwardIterator1 last1, 8480b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2); 8490b57cec5SDimitry Andric 8500b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> 8510b57cec5SDimitry Andric constexpr ForwardIterator1 // constexpr in C++20 8520b57cec5SDimitry Andric search(ForwardIterator1 first1, ForwardIterator1 last1, 8530b57cec5SDimitry Andric ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); 8540b57cec5SDimitry Andric 8550b57cec5SDimitry Andrictemplate <class ForwardIterator, class Size, class T> 8560b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 8570b57cec5SDimitry Andric search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); 8580b57cec5SDimitry Andric 8590b57cec5SDimitry Andrictemplate <class ForwardIterator, class Size, class T, class BinaryPredicate> 8600b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 8610b57cec5SDimitry Andric search_n(ForwardIterator first, ForwardIterator last, 8620b57cec5SDimitry Andric Size count, const T& value, BinaryPredicate pred); 8630b57cec5SDimitry Andric 8640b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator> 865480093f4SDimitry Andric constexpr OutputIterator // constexpr in C++20 8660b57cec5SDimitry Andric copy(InputIterator first, InputIterator last, OutputIterator result); 8670b57cec5SDimitry Andric 8680b57cec5SDimitry Andrictemplate<class InputIterator, class OutputIterator, class Predicate> 869480093f4SDimitry Andric constexpr OutputIterator // constexpr in C++20 8700b57cec5SDimitry Andric copy_if(InputIterator first, InputIterator last, 8710b57cec5SDimitry Andric OutputIterator result, Predicate pred); 8720b57cec5SDimitry Andric 8730b57cec5SDimitry Andrictemplate<class InputIterator, class Size, class OutputIterator> 874480093f4SDimitry Andric constexpr OutputIterator // constexpr in C++20 8750b57cec5SDimitry Andric copy_n(InputIterator first, Size n, OutputIterator result); 8760b57cec5SDimitry Andric 8770b57cec5SDimitry Andrictemplate <class BidirectionalIterator1, class BidirectionalIterator2> 878480093f4SDimitry Andric constexpr BidirectionalIterator2 // constexpr in C++20 8790b57cec5SDimitry Andric copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 8800b57cec5SDimitry Andric BidirectionalIterator2 result); 8810b57cec5SDimitry Andric 88281ad6265SDimitry Andric// [alg.move], move 88381ad6265SDimitry Andrictemplate<class InputIterator, class OutputIterator> 88481ad6265SDimitry Andric constexpr OutputIterator move(InputIterator first, InputIterator last, 88581ad6265SDimitry Andric OutputIterator result); 88681ad6265SDimitry Andric 88781ad6265SDimitry Andrictemplate<class BidirectionalIterator1, class BidirectionalIterator2> 88881ad6265SDimitry Andric constexpr BidirectionalIterator2 88981ad6265SDimitry Andric move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, 89081ad6265SDimitry Andric BidirectionalIterator2 result); 89181ad6265SDimitry Andric 8920b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 893e8d8bef9SDimitry Andric constexpr ForwardIterator2 // constexpr in C++20 8940b57cec5SDimitry Andric swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); 8950b57cec5SDimitry Andric 89681ad6265SDimitry Andricnamespace ranges { 89781ad6265SDimitry Andric template<class I1, class I2> 89881ad6265SDimitry Andric using swap_ranges_result = in_in_result<I1, I2>; 89981ad6265SDimitry Andric 90081ad6265SDimitry Andrictemplate<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2> 90181ad6265SDimitry Andric requires indirectly_swappable<I1, I2> 90281ad6265SDimitry Andric constexpr ranges::swap_ranges_result<I1, I2> 90381ad6265SDimitry Andric swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2); 90481ad6265SDimitry Andric 90581ad6265SDimitry Andrictemplate<input_range R1, input_range R2> 90681ad6265SDimitry Andric requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>> 90781ad6265SDimitry Andric constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> 90881ad6265SDimitry Andric swap_ranges(R1&& r1, R2&& r2); 90981ad6265SDimitry Andric} 91081ad6265SDimitry Andric 9110b57cec5SDimitry Andrictemplate <class ForwardIterator1, class ForwardIterator2> 912e8d8bef9SDimitry Andric constexpr void // constexpr in C++20 9130b57cec5SDimitry Andric iter_swap(ForwardIterator1 a, ForwardIterator2 b); 9140b57cec5SDimitry Andric 9150b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class UnaryOperation> 9160b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9170b57cec5SDimitry Andric transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); 9180b57cec5SDimitry Andric 9190b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> 9200b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9210b57cec5SDimitry Andric transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, 9220b57cec5SDimitry Andric OutputIterator result, BinaryOperation binary_op); 9230b57cec5SDimitry Andric 9240b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 9250b57cec5SDimitry Andric constexpr void // constexpr in C++20 9260b57cec5SDimitry Andric replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); 9270b57cec5SDimitry Andric 9280b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate, class T> 9290b57cec5SDimitry Andric constexpr void // constexpr in C++20 9300b57cec5SDimitry Andric replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); 9310b57cec5SDimitry Andric 9320b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class T> 9330b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9340b57cec5SDimitry Andric replace_copy(InputIterator first, InputIterator last, OutputIterator result, 9350b57cec5SDimitry Andric const T& old_value, const T& new_value); 9360b57cec5SDimitry Andric 9370b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class Predicate, class T> 9380b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9390b57cec5SDimitry Andric replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value); 9400b57cec5SDimitry Andric 9410b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 9420b57cec5SDimitry Andric constexpr void // constexpr in C++20 9430b57cec5SDimitry Andric fill(ForwardIterator first, ForwardIterator last, const T& value); 9440b57cec5SDimitry Andric 9450b57cec5SDimitry Andrictemplate <class OutputIterator, class Size, class T> 9460b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9470b57cec5SDimitry Andric fill_n(OutputIterator first, Size n, const T& value); 9480b57cec5SDimitry Andric 9490b57cec5SDimitry Andrictemplate <class ForwardIterator, class Generator> 9500b57cec5SDimitry Andric constexpr void // constexpr in C++20 9510b57cec5SDimitry Andric generate(ForwardIterator first, ForwardIterator last, Generator gen); 9520b57cec5SDimitry Andric 9530b57cec5SDimitry Andrictemplate <class OutputIterator, class Size, class Generator> 9540b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9550b57cec5SDimitry Andric generate_n(OutputIterator first, Size n, Generator gen); 9560b57cec5SDimitry Andric 9570b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 9580b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 9590b57cec5SDimitry Andric remove(ForwardIterator first, ForwardIterator last, const T& value); 9600b57cec5SDimitry Andric 9610b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate> 9620b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 9630b57cec5SDimitry Andric remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); 9640b57cec5SDimitry Andric 9650b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class T> 9660b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9670b57cec5SDimitry Andric remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); 9680b57cec5SDimitry Andric 9690b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class Predicate> 9700b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9710b57cec5SDimitry Andric remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); 9720b57cec5SDimitry Andric 9730b57cec5SDimitry Andrictemplate <class ForwardIterator> 974e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 9750b57cec5SDimitry Andric unique(ForwardIterator first, ForwardIterator last); 9760b57cec5SDimitry Andric 9770b57cec5SDimitry Andrictemplate <class ForwardIterator, class BinaryPredicate> 978e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 9790b57cec5SDimitry Andric unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); 9800b57cec5SDimitry Andric 9810b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator> 982e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 9830b57cec5SDimitry Andric unique_copy(InputIterator first, InputIterator last, OutputIterator result); 9840b57cec5SDimitry Andric 9850b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator, class BinaryPredicate> 986e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 9870b57cec5SDimitry Andric unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); 9880b57cec5SDimitry Andric 9890b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 990e8d8bef9SDimitry Andric constexpr void // constexpr in C++20 9910b57cec5SDimitry Andric reverse(BidirectionalIterator first, BidirectionalIterator last); 9920b57cec5SDimitry Andric 9930b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class OutputIterator> 9940b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 9950b57cec5SDimitry Andric reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); 9960b57cec5SDimitry Andric 9970b57cec5SDimitry Andrictemplate <class ForwardIterator> 998e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 9990b57cec5SDimitry Andric rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); 10000b57cec5SDimitry Andric 10010b57cec5SDimitry Andrictemplate <class ForwardIterator, class OutputIterator> 1002e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 10030b57cec5SDimitry Andric rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); 10040b57cec5SDimitry Andric 10050b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 10060b57cec5SDimitry Andric void 10070b57cec5SDimitry Andric random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17 10080b57cec5SDimitry Andric 10090b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class RandomNumberGenerator> 10100b57cec5SDimitry Andric void 10110b57cec5SDimitry Andric random_shuffle(RandomAccessIterator first, RandomAccessIterator last, 10120b57cec5SDimitry Andric RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17 10130b57cec5SDimitry Andric 10140b57cec5SDimitry Andrictemplate<class PopulationIterator, class SampleIterator, 10150b57cec5SDimitry Andric class Distance, class UniformRandomBitGenerator> 10160b57cec5SDimitry Andric SampleIterator sample(PopulationIterator first, PopulationIterator last, 10170b57cec5SDimitry Andric SampleIterator out, Distance n, 10180b57cec5SDimitry Andric UniformRandomBitGenerator&& g); // C++17 10190b57cec5SDimitry Andric 10200b57cec5SDimitry Andrictemplate<class RandomAccessIterator, class UniformRandomNumberGenerator> 10210b57cec5SDimitry Andric void shuffle(RandomAccessIterator first, RandomAccessIterator last, 10220b57cec5SDimitry Andric UniformRandomNumberGenerator&& g); 10230b57cec5SDimitry Andric 1024e8d8bef9SDimitry Andrictemplate<class ForwardIterator> 1025e8d8bef9SDimitry Andric constexpr ForwardIterator 1026e8d8bef9SDimitry Andric shift_left(ForwardIterator first, ForwardIterator last, 1027e8d8bef9SDimitry Andric typename iterator_traits<ForwardIterator>::difference_type n); // C++20 1028e8d8bef9SDimitry Andric 1029e8d8bef9SDimitry Andrictemplate<class ForwardIterator> 1030e8d8bef9SDimitry Andric constexpr ForwardIterator 1031e8d8bef9SDimitry Andric shift_right(ForwardIterator first, ForwardIterator last, 1032e8d8bef9SDimitry Andric typename iterator_traits<ForwardIterator>::difference_type n); // C++20 1033e8d8bef9SDimitry Andric 10340b57cec5SDimitry Andrictemplate <class InputIterator, class Predicate> 10350b57cec5SDimitry Andric constexpr bool // constexpr in C++20 10360b57cec5SDimitry Andric is_partitioned(InputIterator first, InputIterator last, Predicate pred); 10370b57cec5SDimitry Andric 10380b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate> 1039e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++20 10400b57cec5SDimitry Andric partition(ForwardIterator first, ForwardIterator last, Predicate pred); 10410b57cec5SDimitry Andric 10420b57cec5SDimitry Andrictemplate <class InputIterator, class OutputIterator1, 10430b57cec5SDimitry Andric class OutputIterator2, class Predicate> 10440b57cec5SDimitry Andric constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20 10450b57cec5SDimitry Andric partition_copy(InputIterator first, InputIterator last, 10460b57cec5SDimitry Andric OutputIterator1 out_true, OutputIterator2 out_false, 10470b57cec5SDimitry Andric Predicate pred); 10480b57cec5SDimitry Andric 10490b57cec5SDimitry Andrictemplate <class ForwardIterator, class Predicate> 10500b57cec5SDimitry Andric ForwardIterator 10510b57cec5SDimitry Andric stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred); 10520b57cec5SDimitry Andric 10530b57cec5SDimitry Andrictemplate<class ForwardIterator, class Predicate> 10540b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 10550b57cec5SDimitry Andric partition_point(ForwardIterator first, ForwardIterator last, Predicate pred); 10560b57cec5SDimitry Andric 10570b57cec5SDimitry Andrictemplate <class ForwardIterator> 10580b57cec5SDimitry Andric constexpr bool // constexpr in C++20 10590b57cec5SDimitry Andric is_sorted(ForwardIterator first, ForwardIterator last); 10600b57cec5SDimitry Andric 10610b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1062e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 10630b57cec5SDimitry Andric is_sorted(ForwardIterator first, ForwardIterator last, Compare comp); 10640b57cec5SDimitry Andric 10650b57cec5SDimitry Andrictemplate<class ForwardIterator> 10660b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 10670b57cec5SDimitry Andric is_sorted_until(ForwardIterator first, ForwardIterator last); 10680b57cec5SDimitry Andric 10690b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 10700b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 10710b57cec5SDimitry Andric is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp); 10720b57cec5SDimitry Andric 10730b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1074fe6060f1SDimitry Andric constexpr void // constexpr in C++20 10750b57cec5SDimitry Andric sort(RandomAccessIterator first, RandomAccessIterator last); 10760b57cec5SDimitry Andric 10770b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1078fe6060f1SDimitry Andric constexpr void // constexpr in C++20 10790b57cec5SDimitry Andric sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 10800b57cec5SDimitry Andric 10810b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 10820b57cec5SDimitry Andric void 10830b57cec5SDimitry Andric stable_sort(RandomAccessIterator first, RandomAccessIterator last); 10840b57cec5SDimitry Andric 10850b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 10860b57cec5SDimitry Andric void 10870b57cec5SDimitry Andric stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 10880b57cec5SDimitry Andric 10890b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1090fe6060f1SDimitry Andric constexpr void // constexpr in C++20 10910b57cec5SDimitry Andric partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); 10920b57cec5SDimitry Andric 10930b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1094fe6060f1SDimitry Andric constexpr void // constexpr in C++20 10950b57cec5SDimitry Andric partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); 10960b57cec5SDimitry Andric 10970b57cec5SDimitry Andrictemplate <class InputIterator, class RandomAccessIterator> 1098fe6060f1SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 10990b57cec5SDimitry Andric partial_sort_copy(InputIterator first, InputIterator last, 11000b57cec5SDimitry Andric RandomAccessIterator result_first, RandomAccessIterator result_last); 11010b57cec5SDimitry Andric 11020b57cec5SDimitry Andrictemplate <class InputIterator, class RandomAccessIterator, class Compare> 1103fe6060f1SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 11040b57cec5SDimitry Andric partial_sort_copy(InputIterator first, InputIterator last, 11050b57cec5SDimitry Andric RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); 11060b57cec5SDimitry Andric 11070b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1108fe6060f1SDimitry Andric constexpr void // constexpr in C++20 11090b57cec5SDimitry Andric nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); 11100b57cec5SDimitry Andric 11110b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1112fe6060f1SDimitry Andric constexpr void // constexpr in C++20 11130b57cec5SDimitry Andric nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); 11140b57cec5SDimitry Andric 11150b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 11160b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 11170b57cec5SDimitry Andric lower_bound(ForwardIterator first, ForwardIterator last, const T& value); 11180b57cec5SDimitry Andric 11190b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 11200b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 11210b57cec5SDimitry Andric lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 11220b57cec5SDimitry Andric 11230b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 11240b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 11250b57cec5SDimitry Andric upper_bound(ForwardIterator first, ForwardIterator last, const T& value); 11260b57cec5SDimitry Andric 11270b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 11280b57cec5SDimitry Andric constexpr ForwardIterator // constexpr in C++20 11290b57cec5SDimitry Andric upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 11300b57cec5SDimitry Andric 11310b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 11320b57cec5SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20 11330b57cec5SDimitry Andric equal_range(ForwardIterator first, ForwardIterator last, const T& value); 11340b57cec5SDimitry Andric 11350b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 11360b57cec5SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20 11370b57cec5SDimitry Andric equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 11380b57cec5SDimitry Andric 11390b57cec5SDimitry Andrictemplate <class ForwardIterator, class T> 11400b57cec5SDimitry Andric constexpr bool // constexpr in C++20 11410b57cec5SDimitry Andric binary_search(ForwardIterator first, ForwardIterator last, const T& value); 11420b57cec5SDimitry Andric 11430b57cec5SDimitry Andrictemplate <class ForwardIterator, class T, class Compare> 11440b57cec5SDimitry Andric constexpr bool // constexpr in C++20 11450b57cec5SDimitry Andric binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); 11460b57cec5SDimitry Andric 11470b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1148e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 11490b57cec5SDimitry Andric merge(InputIterator1 first1, InputIterator1 last1, 11500b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 11510b57cec5SDimitry Andric 11520b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1153e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 11540b57cec5SDimitry Andric merge(InputIterator1 first1, InputIterator1 last1, 11550b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 11560b57cec5SDimitry Andric 11570b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 11580b57cec5SDimitry Andric void 11590b57cec5SDimitry Andric inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); 11600b57cec5SDimitry Andric 11610b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Compare> 11620b57cec5SDimitry Andric void 11630b57cec5SDimitry Andric inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); 11640b57cec5SDimitry Andric 11650b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 11660b57cec5SDimitry Andric constexpr bool // constexpr in C++20 11670b57cec5SDimitry Andric includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 11680b57cec5SDimitry Andric 11690b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class Compare> 11700b57cec5SDimitry Andric constexpr bool // constexpr in C++20 11710b57cec5SDimitry Andric includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); 11720b57cec5SDimitry Andric 11730b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1174e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 11750b57cec5SDimitry Andric set_union(InputIterator1 first1, InputIterator1 last1, 11760b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 11770b57cec5SDimitry Andric 11780b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1179e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 11800b57cec5SDimitry Andric set_union(InputIterator1 first1, InputIterator1 last1, 11810b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 11820b57cec5SDimitry Andric 11830b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 11840b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 11850b57cec5SDimitry Andric set_intersection(InputIterator1 first1, InputIterator1 last1, 11860b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 11870b57cec5SDimitry Andric 11880b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 11890b57cec5SDimitry Andric constexpr OutputIterator // constexpr in C++20 11900b57cec5SDimitry Andric set_intersection(InputIterator1 first1, InputIterator1 last1, 11910b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 11920b57cec5SDimitry Andric 11930b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1194e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 11950b57cec5SDimitry Andric set_difference(InputIterator1 first1, InputIterator1 last1, 11960b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 11970b57cec5SDimitry Andric 11980b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1199e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 12000b57cec5SDimitry Andric set_difference(InputIterator1 first1, InputIterator1 last1, 12010b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 12020b57cec5SDimitry Andric 12030b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator> 1204e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 12050b57cec5SDimitry Andric set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 12060b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result); 12070b57cec5SDimitry Andric 12080b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> 1209e8d8bef9SDimitry Andric constexpr OutputIterator // constexpr in C++20 12100b57cec5SDimitry Andric set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, 12110b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); 12120b57cec5SDimitry Andric 12130b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1214fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12150b57cec5SDimitry Andric push_heap(RandomAccessIterator first, RandomAccessIterator last); 12160b57cec5SDimitry Andric 12170b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1218fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12190b57cec5SDimitry Andric push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 12200b57cec5SDimitry Andric 12210b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1222fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12230b57cec5SDimitry Andric pop_heap(RandomAccessIterator first, RandomAccessIterator last); 12240b57cec5SDimitry Andric 12250b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1226fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12270b57cec5SDimitry Andric pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 12280b57cec5SDimitry Andric 12290b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1230fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12310b57cec5SDimitry Andric make_heap(RandomAccessIterator first, RandomAccessIterator last); 12320b57cec5SDimitry Andric 12330b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1234fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12350b57cec5SDimitry Andric make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 12360b57cec5SDimitry Andric 12370b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 1238fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12390b57cec5SDimitry Andric sort_heap(RandomAccessIterator first, RandomAccessIterator last); 12400b57cec5SDimitry Andric 12410b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 1242fe6060f1SDimitry Andric constexpr void // constexpr in C++20 12430b57cec5SDimitry Andric sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); 12440b57cec5SDimitry Andric 12450b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 12460b57cec5SDimitry Andric constexpr bool // constexpr in C++20 12470b57cec5SDimitry Andric is_heap(RandomAccessIterator first, RandomAccessiterator last); 12480b57cec5SDimitry Andric 12490b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 12500b57cec5SDimitry Andric constexpr bool // constexpr in C++20 12510b57cec5SDimitry Andric is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 12520b57cec5SDimitry Andric 12530b57cec5SDimitry Andrictemplate <class RandomAccessIterator> 12540b57cec5SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 12550b57cec5SDimitry Andric is_heap_until(RandomAccessIterator first, RandomAccessiterator last); 12560b57cec5SDimitry Andric 12570b57cec5SDimitry Andrictemplate <class RandomAccessIterator, class Compare> 12580b57cec5SDimitry Andric constexpr RandomAccessIterator // constexpr in C++20 12590b57cec5SDimitry Andric is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp); 12600b57cec5SDimitry Andric 12610b57cec5SDimitry Andrictemplate <class ForwardIterator> 1262e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1263e8d8bef9SDimitry Andric min_element(ForwardIterator first, ForwardIterator last); 12640b57cec5SDimitry Andric 12650b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1266e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1267e8d8bef9SDimitry Andric min_element(ForwardIterator first, ForwardIterator last, Compare comp); 12680b57cec5SDimitry Andric 12690b57cec5SDimitry Andrictemplate <class T> 1270e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1271e8d8bef9SDimitry Andric min(const T& a, const T& b); 12720b57cec5SDimitry Andric 12730b57cec5SDimitry Andrictemplate <class T, class Compare> 1274e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1275e8d8bef9SDimitry Andric min(const T& a, const T& b, Compare comp); 12760b57cec5SDimitry Andric 12770b57cec5SDimitry Andrictemplate<class T> 1278e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1279e8d8bef9SDimitry Andric min(initializer_list<T> t); 12800b57cec5SDimitry Andric 12810b57cec5SDimitry Andrictemplate<class T, class Compare> 1282e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1283e8d8bef9SDimitry Andric min(initializer_list<T> t, Compare comp); 12840b57cec5SDimitry Andric 12850b57cec5SDimitry Andrictemplate<class T> 12860b57cec5SDimitry Andric constexpr const T& clamp(const T& v, const T& lo, const T& hi); // C++17 12870b57cec5SDimitry Andric 12880b57cec5SDimitry Andrictemplate<class T, class Compare> 12890b57cec5SDimitry Andric constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17 12900b57cec5SDimitry Andric 12910b57cec5SDimitry Andrictemplate <class ForwardIterator> 1292e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1293e8d8bef9SDimitry Andric max_element(ForwardIterator first, ForwardIterator last); 12940b57cec5SDimitry Andric 12950b57cec5SDimitry Andrictemplate <class ForwardIterator, class Compare> 1296e8d8bef9SDimitry Andric constexpr ForwardIterator // constexpr in C++14 1297e8d8bef9SDimitry Andric max_element(ForwardIterator first, ForwardIterator last, Compare comp); 12980b57cec5SDimitry Andric 12990b57cec5SDimitry Andrictemplate <class T> 1300e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1301e8d8bef9SDimitry Andric max(const T& a, const T& b); 13020b57cec5SDimitry Andric 13030b57cec5SDimitry Andrictemplate <class T, class Compare> 1304e8d8bef9SDimitry Andric constexpr const T& // constexpr in C++14 1305e8d8bef9SDimitry Andric max(const T& a, const T& b, Compare comp); 13060b57cec5SDimitry Andric 13070b57cec5SDimitry Andrictemplate<class T> 1308e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1309e8d8bef9SDimitry Andric max(initializer_list<T> t); 13100b57cec5SDimitry Andric 13110b57cec5SDimitry Andrictemplate<class T, class Compare> 1312e8d8bef9SDimitry Andric constexpr T // constexpr in C++14 1313e8d8bef9SDimitry Andric max(initializer_list<T> t, Compare comp); 13140b57cec5SDimitry Andric 13150b57cec5SDimitry Andrictemplate<class ForwardIterator> 1316e8d8bef9SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14 1317e8d8bef9SDimitry Andric minmax_element(ForwardIterator first, ForwardIterator last); 13180b57cec5SDimitry Andric 13190b57cec5SDimitry Andrictemplate<class ForwardIterator, class Compare> 1320e8d8bef9SDimitry Andric constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14 1321e8d8bef9SDimitry Andric minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); 13220b57cec5SDimitry Andric 13230b57cec5SDimitry Andrictemplate<class T> 1324e8d8bef9SDimitry Andric constexpr pair<const T&, const T&> // constexpr in C++14 1325e8d8bef9SDimitry Andric minmax(const T& a, const T& b); 13260b57cec5SDimitry Andric 13270b57cec5SDimitry Andrictemplate<class T, class Compare> 1328e8d8bef9SDimitry Andric constexpr pair<const T&, const T&> // constexpr in C++14 1329e8d8bef9SDimitry Andric minmax(const T& a, const T& b, Compare comp); 13300b57cec5SDimitry Andric 13310b57cec5SDimitry Andrictemplate<class T> 1332e8d8bef9SDimitry Andric constexpr pair<T, T> // constexpr in C++14 1333e8d8bef9SDimitry Andric minmax(initializer_list<T> t); 13340b57cec5SDimitry Andric 13350b57cec5SDimitry Andrictemplate<class T, class Compare> 1336e8d8bef9SDimitry Andric constexpr pair<T, T> // constexpr in C++14 1337e8d8bef9SDimitry Andric minmax(initializer_list<T> t, Compare comp); 13380b57cec5SDimitry Andric 13390b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2> 13400b57cec5SDimitry Andric constexpr bool // constexpr in C++20 13410b57cec5SDimitry Andric lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); 13420b57cec5SDimitry Andric 13430b57cec5SDimitry Andrictemplate <class InputIterator1, class InputIterator2, class Compare> 13440b57cec5SDimitry Andric constexpr bool // constexpr in C++20 13450b57cec5SDimitry Andric lexicographical_compare(InputIterator1 first1, InputIterator1 last1, 13460b57cec5SDimitry Andric InputIterator2 first2, InputIterator2 last2, Compare comp); 13470b57cec5SDimitry Andric 13480b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 1349e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 13500b57cec5SDimitry Andric next_permutation(BidirectionalIterator first, BidirectionalIterator last); 13510b57cec5SDimitry Andric 13520b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Compare> 1353e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 13540b57cec5SDimitry Andric next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 13550b57cec5SDimitry Andric 13560b57cec5SDimitry Andrictemplate <class BidirectionalIterator> 1357e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 13580b57cec5SDimitry Andric prev_permutation(BidirectionalIterator first, BidirectionalIterator last); 13590b57cec5SDimitry Andric 13600b57cec5SDimitry Andrictemplate <class BidirectionalIterator, class Compare> 1361e8d8bef9SDimitry Andric constexpr bool // constexpr in C++20 13620b57cec5SDimitry Andric prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 13630b57cec5SDimitry Andric} // std 13640b57cec5SDimitry Andric 13650b57cec5SDimitry Andric*/ 13660b57cec5SDimitry Andric 136781ad6265SDimitry Andric#include <__assert> // all public C++ headers provide the assertion handler 136881ad6265SDimitry Andric#include <__bits> 13690b57cec5SDimitry Andric#include <__config> 1370fe6060f1SDimitry Andric#include <__debug> 1371fe6060f1SDimitry Andric#include <cstddef> 13720b57cec5SDimitry Andric#include <cstring> 1373fe6060f1SDimitry Andric#include <memory> 1374fe6060f1SDimitry Andric#include <type_traits> 13750b57cec5SDimitry Andric#include <version> 13760b57cec5SDimitry Andric 1377fe6060f1SDimitry Andric#include <__algorithm/adjacent_find.h> 1378fe6060f1SDimitry Andric#include <__algorithm/all_of.h> 1379fe6060f1SDimitry Andric#include <__algorithm/any_of.h> 1380fe6060f1SDimitry Andric#include <__algorithm/binary_search.h> 1381fe6060f1SDimitry Andric#include <__algorithm/clamp.h> 1382fe6060f1SDimitry Andric#include <__algorithm/comp.h> 1383fe6060f1SDimitry Andric#include <__algorithm/comp_ref_type.h> 1384fe6060f1SDimitry Andric#include <__algorithm/copy.h> 1385fe6060f1SDimitry Andric#include <__algorithm/copy_backward.h> 1386fe6060f1SDimitry Andric#include <__algorithm/copy_if.h> 1387fe6060f1SDimitry Andric#include <__algorithm/copy_n.h> 1388fe6060f1SDimitry Andric#include <__algorithm/count.h> 1389fe6060f1SDimitry Andric#include <__algorithm/count_if.h> 1390fe6060f1SDimitry Andric#include <__algorithm/equal.h> 1391fe6060f1SDimitry Andric#include <__algorithm/equal_range.h> 1392fe6060f1SDimitry Andric#include <__algorithm/fill.h> 139304eeddc0SDimitry Andric#include <__algorithm/fill_n.h> 1394fe6060f1SDimitry Andric#include <__algorithm/find.h> 1395fe6060f1SDimitry Andric#include <__algorithm/find_end.h> 1396fe6060f1SDimitry Andric#include <__algorithm/find_first_of.h> 1397fe6060f1SDimitry Andric#include <__algorithm/find_if.h> 1398fe6060f1SDimitry Andric#include <__algorithm/find_if_not.h> 1399fe6060f1SDimitry Andric#include <__algorithm/for_each.h> 1400fe6060f1SDimitry Andric#include <__algorithm/for_each_n.h> 1401fe6060f1SDimitry Andric#include <__algorithm/generate.h> 140204eeddc0SDimitry Andric#include <__algorithm/generate_n.h> 1403fe6060f1SDimitry Andric#include <__algorithm/half_positive.h> 140481ad6265SDimitry Andric#include <__algorithm/in_found_result.h> 140581ad6265SDimitry Andric#include <__algorithm/in_fun_result.h> 14061fd87a68SDimitry Andric#include <__algorithm/in_in_out_result.h> 140704eeddc0SDimitry Andric#include <__algorithm/in_in_result.h> 140881ad6265SDimitry Andric#include <__algorithm/in_out_out_result.h> 140904eeddc0SDimitry Andric#include <__algorithm/in_out_result.h> 1410fe6060f1SDimitry Andric#include <__algorithm/includes.h> 1411fe6060f1SDimitry Andric#include <__algorithm/inplace_merge.h> 1412fe6060f1SDimitry Andric#include <__algorithm/is_heap.h> 1413fe6060f1SDimitry Andric#include <__algorithm/is_heap_until.h> 1414fe6060f1SDimitry Andric#include <__algorithm/is_partitioned.h> 1415fe6060f1SDimitry Andric#include <__algorithm/is_permutation.h> 1416fe6060f1SDimitry Andric#include <__algorithm/is_sorted.h> 1417fe6060f1SDimitry Andric#include <__algorithm/is_sorted_until.h> 1418fe6060f1SDimitry Andric#include <__algorithm/iter_swap.h> 1419fe6060f1SDimitry Andric#include <__algorithm/lexicographical_compare.h> 1420fe6060f1SDimitry Andric#include <__algorithm/lower_bound.h> 1421fe6060f1SDimitry Andric#include <__algorithm/make_heap.h> 1422fe6060f1SDimitry Andric#include <__algorithm/max.h> 1423fe6060f1SDimitry Andric#include <__algorithm/max_element.h> 1424fe6060f1SDimitry Andric#include <__algorithm/merge.h> 1425fe6060f1SDimitry Andric#include <__algorithm/min.h> 1426fe6060f1SDimitry Andric#include <__algorithm/min_element.h> 142781ad6265SDimitry Andric#include <__algorithm/min_max_result.h> 1428fe6060f1SDimitry Andric#include <__algorithm/minmax.h> 1429fe6060f1SDimitry Andric#include <__algorithm/minmax_element.h> 1430fe6060f1SDimitry Andric#include <__algorithm/mismatch.h> 1431fe6060f1SDimitry Andric#include <__algorithm/move.h> 1432fe6060f1SDimitry Andric#include <__algorithm/move_backward.h> 1433fe6060f1SDimitry Andric#include <__algorithm/next_permutation.h> 1434fe6060f1SDimitry Andric#include <__algorithm/none_of.h> 1435fe6060f1SDimitry Andric#include <__algorithm/nth_element.h> 1436fe6060f1SDimitry Andric#include <__algorithm/partial_sort.h> 1437fe6060f1SDimitry Andric#include <__algorithm/partial_sort_copy.h> 1438fe6060f1SDimitry Andric#include <__algorithm/partition.h> 1439fe6060f1SDimitry Andric#include <__algorithm/partition_copy.h> 1440fe6060f1SDimitry Andric#include <__algorithm/partition_point.h> 1441fe6060f1SDimitry Andric#include <__algorithm/pop_heap.h> 1442fe6060f1SDimitry Andric#include <__algorithm/prev_permutation.h> 1443fe6060f1SDimitry Andric#include <__algorithm/push_heap.h> 144481ad6265SDimitry Andric#include <__algorithm/ranges_adjacent_find.h> 144581ad6265SDimitry Andric#include <__algorithm/ranges_all_of.h> 144681ad6265SDimitry Andric#include <__algorithm/ranges_any_of.h> 144781ad6265SDimitry Andric#include <__algorithm/ranges_binary_search.h> 144881ad6265SDimitry Andric#include <__algorithm/ranges_copy.h> 144981ad6265SDimitry Andric#include <__algorithm/ranges_copy_backward.h> 145081ad6265SDimitry Andric#include <__algorithm/ranges_copy_if.h> 145181ad6265SDimitry Andric#include <__algorithm/ranges_copy_n.h> 145281ad6265SDimitry Andric#include <__algorithm/ranges_count.h> 145381ad6265SDimitry Andric#include <__algorithm/ranges_count_if.h> 145481ad6265SDimitry Andric#include <__algorithm/ranges_equal.h> 145581ad6265SDimitry Andric#include <__algorithm/ranges_fill.h> 145681ad6265SDimitry Andric#include <__algorithm/ranges_fill_n.h> 145781ad6265SDimitry Andric#include <__algorithm/ranges_find.h> 1458*753f127fSDimitry Andric#include <__algorithm/ranges_find_end.h> 145981ad6265SDimitry Andric#include <__algorithm/ranges_find_first_of.h> 146081ad6265SDimitry Andric#include <__algorithm/ranges_find_if.h> 146181ad6265SDimitry Andric#include <__algorithm/ranges_find_if_not.h> 146281ad6265SDimitry Andric#include <__algorithm/ranges_for_each.h> 146381ad6265SDimitry Andric#include <__algorithm/ranges_for_each_n.h> 146481ad6265SDimitry Andric#include <__algorithm/ranges_is_partitioned.h> 146581ad6265SDimitry Andric#include <__algorithm/ranges_is_sorted.h> 146681ad6265SDimitry Andric#include <__algorithm/ranges_is_sorted_until.h> 146781ad6265SDimitry Andric#include <__algorithm/ranges_lexicographical_compare.h> 146881ad6265SDimitry Andric#include <__algorithm/ranges_lower_bound.h> 1469*753f127fSDimitry Andric#include <__algorithm/ranges_make_heap.h> 147081ad6265SDimitry Andric#include <__algorithm/ranges_max.h> 147181ad6265SDimitry Andric#include <__algorithm/ranges_max_element.h> 1472*753f127fSDimitry Andric#include <__algorithm/ranges_merge.h> 147381ad6265SDimitry Andric#include <__algorithm/ranges_min.h> 147481ad6265SDimitry Andric#include <__algorithm/ranges_min_element.h> 147581ad6265SDimitry Andric#include <__algorithm/ranges_minmax.h> 147681ad6265SDimitry Andric#include <__algorithm/ranges_minmax_element.h> 147781ad6265SDimitry Andric#include <__algorithm/ranges_mismatch.h> 147881ad6265SDimitry Andric#include <__algorithm/ranges_move.h> 147981ad6265SDimitry Andric#include <__algorithm/ranges_move_backward.h> 148081ad6265SDimitry Andric#include <__algorithm/ranges_none_of.h> 1481*753f127fSDimitry Andric#include <__algorithm/ranges_nth_element.h> 1482*753f127fSDimitry Andric#include <__algorithm/ranges_pop_heap.h> 1483*753f127fSDimitry Andric#include <__algorithm/ranges_push_heap.h> 1484*753f127fSDimitry Andric#include <__algorithm/ranges_remove.h> 1485*753f127fSDimitry Andric#include <__algorithm/ranges_remove_if.h> 148681ad6265SDimitry Andric#include <__algorithm/ranges_replace.h> 148781ad6265SDimitry Andric#include <__algorithm/ranges_replace_if.h> 148881ad6265SDimitry Andric#include <__algorithm/ranges_reverse.h> 1489*753f127fSDimitry Andric#include <__algorithm/ranges_reverse_copy.h> 1490*753f127fSDimitry Andric#include <__algorithm/ranges_rotate_copy.h> 1491*753f127fSDimitry Andric#include <__algorithm/ranges_search.h> 1492*753f127fSDimitry Andric#include <__algorithm/ranges_search_n.h> 1493*753f127fSDimitry Andric#include <__algorithm/ranges_set_difference.h> 1494*753f127fSDimitry Andric#include <__algorithm/ranges_set_intersection.h> 1495*753f127fSDimitry Andric#include <__algorithm/ranges_set_symmetric_difference.h> 149681ad6265SDimitry Andric#include <__algorithm/ranges_sort.h> 1497*753f127fSDimitry Andric#include <__algorithm/ranges_sort_heap.h> 149881ad6265SDimitry Andric#include <__algorithm/ranges_stable_sort.h> 149981ad6265SDimitry Andric#include <__algorithm/ranges_swap_ranges.h> 150081ad6265SDimitry Andric#include <__algorithm/ranges_transform.h> 150181ad6265SDimitry Andric#include <__algorithm/ranges_upper_bound.h> 1502fe6060f1SDimitry Andric#include <__algorithm/remove.h> 1503fe6060f1SDimitry Andric#include <__algorithm/remove_copy.h> 1504fe6060f1SDimitry Andric#include <__algorithm/remove_copy_if.h> 1505fe6060f1SDimitry Andric#include <__algorithm/remove_if.h> 1506fe6060f1SDimitry Andric#include <__algorithm/replace.h> 1507fe6060f1SDimitry Andric#include <__algorithm/replace_copy.h> 1508fe6060f1SDimitry Andric#include <__algorithm/replace_copy_if.h> 1509fe6060f1SDimitry Andric#include <__algorithm/replace_if.h> 1510fe6060f1SDimitry Andric#include <__algorithm/reverse.h> 1511fe6060f1SDimitry Andric#include <__algorithm/reverse_copy.h> 1512fe6060f1SDimitry Andric#include <__algorithm/rotate.h> 1513fe6060f1SDimitry Andric#include <__algorithm/rotate_copy.h> 1514fe6060f1SDimitry Andric#include <__algorithm/sample.h> 1515fe6060f1SDimitry Andric#include <__algorithm/search.h> 1516fe6060f1SDimitry Andric#include <__algorithm/search_n.h> 1517fe6060f1SDimitry Andric#include <__algorithm/set_difference.h> 1518fe6060f1SDimitry Andric#include <__algorithm/set_intersection.h> 1519fe6060f1SDimitry Andric#include <__algorithm/set_symmetric_difference.h> 1520fe6060f1SDimitry Andric#include <__algorithm/set_union.h> 1521fe6060f1SDimitry Andric#include <__algorithm/shift_left.h> 1522fe6060f1SDimitry Andric#include <__algorithm/shift_right.h> 1523fe6060f1SDimitry Andric#include <__algorithm/shuffle.h> 1524fe6060f1SDimitry Andric#include <__algorithm/sift_down.h> 1525fe6060f1SDimitry Andric#include <__algorithm/sort.h> 1526fe6060f1SDimitry Andric#include <__algorithm/sort_heap.h> 1527fe6060f1SDimitry Andric#include <__algorithm/stable_partition.h> 1528fe6060f1SDimitry Andric#include <__algorithm/stable_sort.h> 1529fe6060f1SDimitry Andric#include <__algorithm/swap_ranges.h> 1530fe6060f1SDimitry Andric#include <__algorithm/transform.h> 1531fe6060f1SDimitry Andric#include <__algorithm/unique.h> 153204eeddc0SDimitry Andric#include <__algorithm/unique_copy.h> 1533fe6060f1SDimitry Andric#include <__algorithm/unwrap_iter.h> 1534fe6060f1SDimitry Andric#include <__algorithm/upper_bound.h> 15350b57cec5SDimitry Andric 153681ad6265SDimitry Andric#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES 153781ad6265SDimitry Andric# include <chrono> 153881ad6265SDimitry Andric# include <iterator> 153981ad6265SDimitry Andric# include <utility> 154081ad6265SDimitry Andric#endif 154181ad6265SDimitry Andric 154281ad6265SDimitry Andric// standard-mandated includes 154381ad6265SDimitry Andric#include <initializer_list> 154481ad6265SDimitry Andric 15450b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 15460b57cec5SDimitry Andric# pragma GCC system_header 15470b57cec5SDimitry Andric#endif 15480b57cec5SDimitry Andric 1549e40139ffSDimitry Andric#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17 1550e40139ffSDimitry Andric# include <__pstl_algorithm> 1551e40139ffSDimitry Andric#endif 1552e40139ffSDimitry Andric 15530b57cec5SDimitry Andric#endif // _LIBCPP_ALGORITHM 1554