algorithm.hpp File Reference

Include dependency graph for algorithm.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
	core
	Copyright © 2013 - 2015 MNMLSTC.
	core::v2
	core::v2::impl

Functions
template<class T , class Compare = ::core::less<>, class Difference = ::core::minus<>>
constexpr auto	abs_diff (T const &a, T const &b, Compare compare=Compare { }, Difference diff=Difference { }) -> decltype(compare(a, b) ? diff(b, a) :diff(a, b))
template < class Range >
auto	adjacent_find (Range &&rng) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class BinaryPredicate >
auto	adjacent_find (Range &&rng, BinaryPredicate &&bp) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class UnaryPredicate >
auto	all_of (Range &&rng, UnaryPredicate &&p) -> meta::when< is_range< Range >::value, bool >
template < class Range , class UnaryPredicate >
auto	any_of (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class T >
auto	binary_search (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class T , class Compare >
auto	binary_search (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
template<class T , class Compare = less<>>
constexpr T const &	clamp (T const &value, T const &low, T const &high, Compare compare=Compare { })
template < class Range , class OutputIt >
auto	copy (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class BidirIt >
auto	copy_backward (Range &&rng, BidirIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< BidirIt > >
template < class Range , class OutputIt , class UnaryPredicate >
auto	copy_if (Range &&rng, OutputIt &&it, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class OutputIt , class T >
OutputIt	copy_until (Range &&r, OutputIt it, T const &value)
template < class Range , class T >
auto	count (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::count(::std::begin(::core::forward< Range >(rng)), ::std::end(::core::forward< Range >(rng)), value)) >
template < class Range , class UnaryPredicate >
auto	count_if (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::count_if(::std::begin(::core::forward< Range >(rng)), ::std::end(::core::forward< Range >(rng)), ::core::forward< UnaryPredicate >(p))) >
template < class InputIt 1 , class InputIt 2 , class Predicate >
bool	equal (range< InputIt1 > r1, range< InputIt2 > r2, Predicate &&p, ::std::random_access_iterator_tag, ::std::random_access_iterator_tag)
template < class InputIt 1 , class InputIt 2 , class Predicate >
bool	equal (range< InputIt1 > r1, range< InputIt2 > r2, Predicate &&p, ::std::input_iterator_tag, ::std::input_iterator_tag)
template < class InputIt 1 , class InputIt 2 , class BinaryPredicate >
bool	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate bp)
template < class InputIt 1 , class InputIt 2 >
bool	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
template<class Range1 , class Range2 , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
bool	equal (Range1 &&range1, Range2 &&range2)
template<class Range1 , class Range2 , class BinaryPredicate , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
bool	equal (Range1 &&range1, Range2 &&range2, BinaryPredicate &&bp)
template<class Range , class InputIt , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >::value >()>() > = __LINE__>
bool	equal (Range &&rng, InputIt &&it)
template<class Range , class InputIt , class BinaryPredicate , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >>()>() > = __LINE__>
bool	equal (Range &&rng, InputIt &&it, BinaryPredicate &&bp)
template < class Range , class T >
auto	equal_range (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, range< decltype(::std::begin(::core::forward< Range >(rng)))> >
template < class Range , class T , class Compare >
auto	equal_range (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, range< decltype(::std::begin(::core::forward< Range >(rng)))> >
template < class Range , class T >
auto	fill (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value >
template < class Range , class T >
auto	find (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range 1 , class Range 2 >
auto	find_end (Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
template < class Range 1 , class Range 2 , class BinaryPred >
auto	find_end (Range1 &&rng1, Range2 &&rng2, BinaryPred &bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
template < class IRange , class FRange >
auto	find_first_of (IRange &&irng, FRange &&frng) -> meta::when< meta::all_of< meta::list< IRange, FRange >, is_range >(), decltype(::std::begin(::core::forward< IRange >(irng))) >
template < class IRange , class FRange , class BinaryPred >
auto	find_first_of (IRange &&irng, FRange &&frng, BinaryPred &&bp) -> meta::when< meta::all_of< meta::list< IRange, FRange >, is_range >(), decltype(::std::begin(::core::forward< IRange >(irng))) >
template < class Range , class UnaryPredicate >
auto	find_if (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class UnaryPredicate >
auto	find_if_not (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class UnaryFunction >
auto	for_each (Range &&rng, UnaryFunction &&f) -> enable_if_t< is_range< Range >::value, decay_t< UnaryFunction > >
template < class Range , class UnaryFunction , class UnaryPredicate >
UnaryFunction	for_each_if (Range &&r, UnaryFunction uf, UnaryPredicate up)
template < class Range , class UnaryFunction , class T >
auto	for_each_until (Range &&r, UnaryFunction f, T const &value) -> decltype(begin(make_range(::core::forward< Range >(r))))
template < class Range , class UnaryFunction , class UnaryPredicate >
auto	for_each_while (Range &&r, UnaryFunction f, UnaryPredicate p) -> decltype(begin(make_range(::core::forward< Range >(r))))
template < class Range 1 , class Range 2 >
auto	includes (Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
template < class Range 1 , class Range 2 , class Compare >
auto	includes (Range1 &&rng1, Range2 &&rng2, Compare &&cmp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
template < class Range , class BidirIt >
auto	inplace_merge (Range &&rng, BidirIt &&it) -> meta::when< is_range< Range >::value >
template < class Range , class BidirIt , class Compare >
auto	inplace_merge (Range &&rng, BidirIt &&it, Compare &&cmp) -> meta::when< is_range< Range >::value >
template < class Range >
auto	is_heap (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class Compare >
auto	is_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
template < class Range >
auto	is_heap_until (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class Compare >
auto	is_heap_until (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class UnaryPredicate >
auto	is_partitioned (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, bool >
template < class Range 1 , class Range 2 >
auto	is_permutation (Range1 &&rng1, Range2 &&rng2) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
template < class Range 1 , class Range 2 , class BinaryPredicate >
auto	is_permutation (Range1 &&rng1, Range2 &&rng2, BinaryPredicate &&bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
template < class Range >
auto	is_sorted (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class Compare >
auto	is_sorted (Range &&rng, Compare &&compare) -> enable_if_t< is_range< Range >::value, bool >
template < class Range >
auto	is_sorted_until (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class Compare >
auto	is_sorted_until (Range &&rng, Compare &&compare) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range 1 , class Range 2 >
auto	lexicographical_compare (Range1 &&rng1, Range2 &&rng2) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
template < class Range 1 , class Range 2 , class Compare >
auto	lexicographical_compare (Range1 &&rng1, Range2 &&rng2, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
template < class Range , class T >
auto	lower_bound (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class T , class Compare >
auto	lower_bound (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range >
auto	make_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class Compare >
auto	make_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class T >
constexpr T const &	max (T const &lhs, T const &rhs)
template < class T , class Compare >
constexpr T const &	max (T const &lhs, T const &rhs, Compare compare)
template < class Range >
auto	max_element (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class Compare >
auto	max_element (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range 1 , class Range 2 , class OutputIt >
auto	merge (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt , class Compare >
auto	merge (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class T >
constexpr T const &	min (T const &lhs, T const &rhs)
template < class T , class Compare >
constexpr T const &	min (T const &lhs, T const &rhs, Compare compare)
template < class Range >
auto	min_element (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class Compare >
auto	min_element (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range >
auto	minmax_element (Range &&rng) -> enable_if_t< is_range< Range >::value, ::std::pair< decltype(::std::begin(::core::forward< Range >(rng))), decltype(::std::end(::core::forward< Range >(rng))) > >
template < class Range , class Compare >
auto	minmax_element (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, ::std::pair< range< decltype(::std::begin(::core::forward< Range >(rng)))>, range< decltype(::std::end(::core::forward< Range >(rng)))> > >
template < class InputIt 1 , class InputIt 2 , class BinaryPredicate >
::std::pair< InputIt1, InputIt2 >	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate predicate)
template < class InputIt 1 , class InputIt 2 >
::std::pair< InputIt1, InputIt2 >	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
template<class Range1 , class Range2 , class BinaryPred , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
auto	mismatch (Range1 &&r1, Range2 &&r2, BinaryPred &&bp) -> ::std::pair< decltype(::std::begin(::core::forward< Range1 >(r1))), decltype(::std::begin(::core::forward< Range2 >(r2))) >
template<class Range , class InputIt , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >::value >()>() > = __LINE__>
auto	mismatch (Range &&rng, InputIt &&it) -> ::std::pair< decltype(make_range(::core::forward< Range >(rng)).begin()), decay_t< InputIt > >
template<class Range , class InputIt , class BinaryPredicate , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >>()>() > = __LINE__>
auto	mismatch (Range &&r, InputIt &&it, BinaryPredicate &&bp) -> ::std::pair< decltype(core::make_range(::core::forward< Range >(r).begin())), decay_t< InputIt > >
template < class Range , class OutputIt >
auto	move (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class BidirIt >
auto	move_backward (Range &&rng, BidirIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< BidirIt > >
template < class Range >
auto	next_permutation (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class Compare >
auto	next_permutation (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class UnaryPredicate >
auto	none_of (Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class RandomIt >
auto	nth_element (Range &&rng, RandomIt &&it) -> enable_if_t< is_range< Range >::value >
template < class Range , class RandomIt , class Compare >
auto	nth_element (Range &&rng, RandomIt &&it, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class Range , class RandomIt >
auto	partial_sort (Range &&rng, RandomIt &&it) -> enable_if_t< is_range< Range >::value >
template < class Range , class RandomIt , class Compare >
auto	partial_sort (Range &&rng, RandomIt &&it, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class IRange , class RRange >
auto	partial_sort_copy (IRange &&irng, RRange &&rrng) -> meta::when< meta::all_of< meta::list< IRange, RRange >, is_range >(), decltype(::std::begin(::core::forward< RRange >(rrng))) >
template < class IRange , class RRange , class Compare >
auto	partial_sort_copy (IRange &&irng, RRange &&rrng, Compare &&cmp) -> meta::when< meta::all_of< meta::list< IRange, RRange >, is_range >(), decltype(::std::begin(::core::forward< RRange >(rrng))) >
template < class Range , class UnaryPredicate >
auto	partition (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class OutputTrue , class OutputFalse , class UnaryPred >
auto	partition_copy (Range &&rng, OutputTrue &&ot, OutputFalse &&of, UnaryPred &&up) -> enable_if_t< is_range< Range >::value, ::std::pair< decay_t< OutputTrue >, decay_t< OutputFalse >> >
template < class Range , class UnaryPredicate >
auto	partition_point (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range >
auto	pop_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class Compare >
auto	pop_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class Range >
auto	prev_permutation (Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
template < class Range , class Compare >
auto	prev_permutation (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
template < class Range >
auto	push_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class Compare >
auto	push_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class Range , class T >
auto	remove (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class OutputIt , class T >
auto	remove_copy (Range &&rng, OutputIt &&it, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class OutputIt , class UnaryPred >
auto	remove_copy_if (Range &&rng, OutputIt &&it, UnaryPred &&up) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class T >
auto	remove_erase (Range &&rng, T const &val) -> enable_if_t< is_range< Range >::value >
template < class Range , class UnaryPred >
auto	remove_erase_if (Range &&rng, UnaryPred &&up) -> enable_if_t< is_range< Range >::value >
template < class Range , class UnaryPredicate >
auto	remove_if (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class T >
auto	replace (Range &&rng, T const &old, T const &value) -> enable_if_t< is_range< Range >::value >
template < class Range , class OutputIt , class T >
auto	replace_copy (Range &&rng, OutputIt &&it, T const &old, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class OutputIt , class UnaryPred , class T >
auto	replace_copy_if (Range &&rng, OutputIt &&it, UnaryPred &&up, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class UnaryPred , class T >
auto	replace_if (Range &&rng, UnaryPred &&up, T const &value) -> enable_if_t< is_range< Range >::value >
template < class Range >
auto	reverse (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class OutputIt >
auto	reverse_copy (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class ForwardIt >
auto	rotate (Range &&rng, ForwardIt &&it) -> enable_if_t< is_range< Range >::value >
template < class Range , class ForwardIt , class OutputIt >
auto	rotate_copy (Range &&rng, ForwardIt &&it, OutputIt &&ot) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range 1 , class Range 2 >
auto	search (Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
template < class Range 1 , class Range 2 , class BinaryPred >
auto	search (Range1 &&rng1, Range2 &&rng2, BinaryPred &&bp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
template < class Range , class Size , class T >
auto	search_n (Range &&rng, Size &&count, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class Size , class T , class BinaryPred >
auto	search_n (Range &&rng, Size &&count, T const &value, BinaryPred &&bp) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range 1 , class Range 2 , class OutputIt >
auto	set_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt , class Compare >
auto	set_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt >
auto	set_intersection (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt , class Compare >
auto	set_intersection (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt >
auto	set_symmetric_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt , class Compare >
auto	set_symmetric_difference (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt >
auto	set_union (Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range 1 , class Range 2 , class OutputIt , class Compare >
auto	set_union (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
template < class Range , class URNG >
auto	shuffle (Range &&rng, URNG &&g) -> enable_if_t< is_range< Range >::value >
template < class Range >
auto	sort (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class Compare >
auto	sort (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class Range >
auto	sort_heap (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class Compare >
auto	sort_heap (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class Range , class UnaryPredicate >
auto	stable_partition (Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range >
auto	stable_sort (Range &&rng) -> enable_if_t< is_range< Range >::value >
template < class Range , class Compare >
auto	stable_sort (Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
template < class Range , class ForwardIt >
auto	swap_ranges (Range &&rng, ForwardIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< ForwardIt > >
template < class Range , class OutputIt , class UnaryOperation >
auto	transform (Range &&rng, OutputIt &&it, UnaryOperation &&op) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template<class Range , class InputIt , class OutputIt , class BinaryOperation , meta::require< meta::all< is_range< Range >::value, meta::none< is_range< InputIt >::value >()>() > = __LINE__>
decay_t< OutputIt >	transform (Range &&r, InputIt &&in, OutputIt &&out, BinaryOperation &&op)
template<class Range1 , class Range2 , class OutputIt , class BinaryOperation , meta::require< meta::all_of< meta::list< Range1, Range2 >, is_range >() > = __LINE__>
decay_t< OutputIt >	transform (Range1 &&rng1, Range2 &&rng2, OutputIt &&it, BinaryOperation &&op)
template < class Range , class OutputIt , class UnaryOperation , class UnaryPred >
auto	transform_if (Range &&rng, OutputIt it, UnaryOperation op, UnaryPred up) -> enable_if_t< is_range< Range >::value, OutputIt >
template < class Range 1 , class Range 2 , class OutputIt , class BinaryOperation , class BinaryPredicate >
auto	transform_if (Range1 &&rng1, Range2 &&rng2, OutputIt it, BinaryOperation op, BinaryPredicate bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), OutputIt >
template < class InputIt , class Size , class OutputIt , class UnaryOp >
OutputIt	transform_n (InputIt in, Size count, OutputIt out, UnaryOp op)
template < class InputIt 1 , class InputIt 2 , class Size , class OutputIt , class UnaryOp >
OutputIt	transform_n (InputIt1 in1, InputIt2 in2, Size count, OutputIt out, UnaryOp op)
template < class Range >
auto	unique (Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class BinaryPredicate >
auto	unique (Range &&rng, BinaryPredicate &&bp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class OutputIt >
auto	unique_copy (Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class OutputIt , class BinaryPred >
auto	unique_copy (Range &&rng, OutputIt &&it, BinaryPred &&bp) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
template < class Range , class T >
auto	upper_bound (Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
template < class Range , class T , class Compare >
auto	upper_bound (Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >