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))) >