14 #ifndef CORE_ALGORITHM_HPP 15 #define CORE_ALGORITHM_HPP 27 template <
class InputIt1,
class InputIt2,
class Predicate>
32 ::std::random_access_iterator_tag,
33 ::std::random_access_iterator_tag
35 if (r1.
size() != r2.
size()) {
return false; }
40 ::core::forward<Predicate>(p)
44 template <
class InputIt1,
class InputIt2,
class Predicate>
49 ::std::input_iterator_tag,
50 ::std::input_iterator_tag
55 ::core::forward<Predicate>(p),
69 constexpr T
const&
min (T
const& lhs, T
const& rhs) {
70 return (rhs < lhs) ? rhs : lhs;
73 template <
class T,
class Compare>
74 constexpr T
const&
min (T
const& lhs, T
const& rhs, Compare compare) {
75 return compare(rhs, lhs) ? rhs : lhs;
79 constexpr T
const&
max (T
const& lhs, T
const& rhs) {
80 return (lhs < rhs) ? rhs : lhs;
83 template <
class T,
class Compare>
84 constexpr T
const&
max (T
const& lhs, T
const& rhs, Compare compare) {
85 return compare(lhs, rhs) ? rhs : lhs;
89 template <
class T,
class Compare=less<>>
94 Compare compare = Compare { }
96 return compare(value, low)
98 : compare(high, value)
106 class Compare = ::core::less<>,
107 class Difference = ::core::minus<>
111 Compare compare = Compare { },
112 Difference diff = Difference { }
113 ) -> decltype(compare(a, b) ? diff(b, a) : diff(a, b)) {
114 return compare(a, b) ? diff(b, a) : diff(a, b);
118 template <
class Range,
class UnaryPredicate>
124 static constexpr
auto is_input = decltype(
range)::is_input;
125 static_assert(is_input,
"all_of requires InputIterators");
129 ::core::forward<UnaryPredicate>(p)
133 template <
class Range,
class UnaryPredicate>
135 is_range<Range>::value,
139 static constexpr
auto is_input = decltype(
range)::is_input;
140 static_assert(is_input,
"any_of requires InputIterators");
144 ::core::forward<UnaryPredicate>(p)
148 template <
class Range,
class UnaryPredicate>
150 is_range<Range>::value,
154 static constexpr
auto is_input = decltype(
range)::is_input;
155 static_assert(is_input,
"none_of requires InputIterators");
159 ::core::forward<UnaryPredicate>(p)
163 template <
class Range,
class UnaryFunction>
165 is_range<Range>::value,
169 static constexpr
auto is_input = decltype(
range)::is_input;
170 static_assert(is_input,
"for_each requires InputIterators");
174 ::core::forward<UnaryFunction>(f)
178 template <
class Range,
class UnaryFunction,
class UnaryPredicate>
181 static constexpr
auto is_input = decltype(
range)::is_input;
182 static_assert(is_input,
"for_each_if requires InputIterators");
190 template <
class Range,
class UnaryFunction,
class UnaryPredicate>
195 ) -> decltype(begin(
make_range(::core::forward<Range>(r)))) {
197 static constexpr
auto is_input = decltype(
range)::is_input;
198 static_assert(is_input,
"for_each_while requires InputIterators");
207 template <
class Range,
class UnaryFunction,
class T>
212 ) -> decltype(begin(
make_range(::core::forward<Range>(r)))) {
214 static constexpr
auto is_input = decltype(
range)::is_input;
215 static_assert(is_input,
"for_each_until requires InputIterators");
224 template <
class Range,
class T>
226 is_range<Range>::value,
229 ::std::begin(::core::forward<Range>(rng)),
230 ::std::end(::core::forward<Range>(rng)),
236 static constexpr
auto is_input = decltype(
range)::is_input;
237 static_assert(is_input,
"count requires InputIterators");
241 template <
class Range,
class UnaryPredicate>
243 is_range<Range>::value,
246 ::std::begin(::core::forward<Range>(rng)),
247 ::std::end(::core::forward<Range>(rng)),
248 ::core::forward<UnaryPredicate>(p)
253 static constexpr
auto is_input = decltype(
range)::is_input;
254 static_assert(is_input,
"count_if requires InputIterators");
258 ::core::forward<UnaryPredicate>(p)
262 template <
class InputIt1,
class InputIt2,
class BinaryPredicate>
268 BinaryPredicate predicate
272 while (not r1.empty() and not r2.empty()) {
273 if (not predicate(r1.front(), r2.front())) {
break; }
277 return ::std::make_pair(r1.begin(), r2.begin());
280 template <
class InputIt1,
class InputIt2>
293 meta::all_of<meta::list<Range1, Range2>,
is_range>()
295 >
auto mismatch (Range1&& r1, Range2&& r2, BinaryPred&& bp) -> ::std::pair<
296 decltype(::std::begin(::core::forward<Range1>(r1))),
297 decltype(::std::begin(::core::forward<Range2>(r2)))
299 auto range1 =
make_range(::core::forward<Range1>(r1));
300 auto range2 =
make_range(::core::forward<Range2>(r2));
301 static constexpr
auto is_input1 = decltype(range1)::is_input;
302 static constexpr
auto is_input2 = decltype(range2)::is_input;
303 static_assert(is_input1 and is_input2,
"mismatch requires InputIterators");
309 ::core::forward<BinaryPred>(bp));
316 meta::all<is_range<Range>::value, meta::none<is_range<InputIt>::value>()>()
319 decltype(
make_range(::core::forward<Range>(rng)).begin()),
323 static constexpr
auto is_input = decltype(
range)::is_input;
324 static_assert(is_input,
"mismatch requires InputIterators");
328 ::core::forward<InputIt>(it)
335 class BinaryPredicate,
337 meta::all<is_range<Range>::value, meta::none<is_range<InputIt>>()>()
339 >
auto mismatch(
Range&& r, InputIt&& it, BinaryPredicate&& bp) -> ::std::pair<
344 static constexpr
auto is_input = decltype(
range)::is_input;
345 static_assert(is_input,
"mismatch requires InputIterators");
349 ::core::forward<InputIt>(it),
350 ::core::forward<BinaryPredicate>(bp)
354 template <
class InputIt1,
class InputIt2,
class BinaryPredicate>
364 using tag1 =
typename decltype(r1)::iterator_category;
365 using tag2 =
typename decltype(r2)::iterator_category;
366 return impl::equal(r1, r2, bp, tag1 { }, tag2 { });
369 template <
class InputIt1,
class InputIt2>
370 bool equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) {
378 meta::all_of<meta::list<Range1, Range2>,
is_range>()
380 >
bool equal (Range1&& range1, Range2&& range2) {
381 auto r1 =
make_range(::core::forward<Range1>(range1));
382 auto r2 =
make_range(::core::forward<Range2>(range2));
383 static constexpr
auto is_input1 = decltype(r1)::is_input;
384 static constexpr
auto is_input2 = decltype(r2)::is_input;
385 static_assert(is_input1,
"equal requires InputIterators");
386 static_assert(is_input2,
"equal requires InputIterators");
387 return (
equal)(r1.begin(), r1.end(), r2.begin(), r2.end());
393 class BinaryPredicate,
395 meta::all_of<meta::list<Range1, Range2>,
is_range>()
397 >
bool equal (Range1&& range1, Range2&& range2, BinaryPredicate&& bp) {
398 auto r1 =
make_range(::core::forward<Range1>(range1));
399 auto r2 =
make_range(::core::forward<Range2>(range2));
400 static constexpr
auto is_input1 = decltype(r1)::is_input;
401 static constexpr
auto is_input2 = decltype(r2)::is_input;
402 static_assert(is_input1,
"equal requires InputIterators");
403 static_assert(is_input2,
"equal requires InputIterators");
409 ::core::forward<BinaryPredicate>(bp)
417 meta::all<is_range<Range>::value, meta::none<is_range<InputIt>::value>()>()
421 static constexpr
auto is_input = decltype(
range)::is_input;
422 static_assert(is_input,
"equal requires InputIterators");
426 ::core::forward<InputIt>(it)
433 class BinaryPredicate,
435 meta::all<is_range<Range>::value, meta::none<is_range<InputIt>>()>()
437 >
bool equal (
Range&& rng, InputIt&& it, BinaryPredicate&& bp) {
439 static constexpr
auto is_input = decltype(
range)::is_input;
440 static_assert(is_input,
"equal requires InputIterators");
444 ::core::forward<InputIt>(it),
445 ::core::forward<BinaryPredicate>(bp)
449 template <
class Range,
class T>
451 is_range<Range>::value,
452 decltype(::std::begin(::core::forward<Range>(rng)))
455 static constexpr
auto is_input = decltype(
range)::is_input;
456 static_assert(is_input,
"find requires InputIterators");
460 template <
class Range,
class UnaryPredicate>
462 is_range<Range>::value,
463 decltype(::std::begin(::core::forward<Range>(rng)))
466 static constexpr
auto is_input = decltype(
range)::is_input;
467 static_assert(is_input,
"find_if requires InputIterators");
471 ::core::forward<UnaryPredicate>(p)
475 template <
class Range,
class UnaryPredicate>
477 is_range<Range>::value,
478 decltype(::std::begin(::core::forward<Range>(rng)))
481 static constexpr
auto is_input = decltype(
range)::is_input;
482 static_assert(is_input,
"find_if_not requires InputIterators");
486 ::core::forward<UnaryPredicate>(p)
490 template <
class Range1,
class Range2>
492 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
493 decltype(::std::begin(::core::forward<Range1>(rng1)))
495 auto range1 =
make_range(::core::forward<Range1>(rng1));
496 auto range2 =
make_range(::core::forward<Range2>(rng2));
497 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
498 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
499 static_assert(is_forward1,
"find_end requires ForwardIterators");
500 static_assert(is_forward2,
"find_end requires ForwardIterators");
502 ::std::begin(range1),
504 ::std::begin(range2),
509 template <
class Range1,
class Range2,
class BinaryPred>
511 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
512 decltype(::std::begin(::core::forward<Range1>(rng1)))
514 auto range1 =
make_range(::core::forward<Range1>(rng1));
515 auto range2 =
make_range(::core::forward<Range2>(rng2));
516 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
517 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
518 static_assert(is_forward1,
"find_end requires ForwardIterators");
519 static_assert(is_forward2,
"find_end requires ForwardIterators");
521 ::std::begin(range1),
523 ::std::begin(range2),
525 ::core::forward<BinaryPred>(bp)
529 template <
class IRange,
class FRange>
531 meta::all_of<meta::list<IRange, FRange>,
is_range>(),
532 decltype(::std::begin(::core::forward<IRange>(irng)))
534 auto irange =
make_range(::core::forward<IRange>(irng));
535 auto frange =
make_range(::core::forward<FRange>(frng));
536 static constexpr
auto is_input = decltype(irange)::is_input;
537 static constexpr
auto is_forward = decltype(frange)::is_forward;
538 static_assert(is_input,
"find_first_of requires InputIterators");
539 static_assert(is_forward,
"find_first_of requires ForwardIterators");
541 ::std::begin(irange),
543 ::std::begin(frange),
548 template <
class IRange,
class FRange,
class BinaryPred>
554 meta::all_of<meta::list<IRange, FRange>,
is_range>(),
555 decltype(::std::begin(::core::forward<IRange>(irng)))
557 auto irange =
make_range(::core::forward<IRange>(irng));
558 auto frange =
make_range(::core::forward<FRange>(frng));
559 static constexpr
auto is_input = decltype(irange)::is_input;
560 static constexpr
auto is_forward = decltype(frange)::is_forward;
561 static_assert(is_input,
"find_first_of requires InputIterators");
562 static_assert(is_forward,
"find_first_of requires ForwardIterators");
564 ::std::begin(irange),
566 ::std::begin(frange),
568 ::core::forward<BinaryPred>(bp)
572 template <
class Range>
574 is_range<Range>::value,
575 decltype(::std::begin(::core::forward<Range>(rng)))
578 static constexpr
auto is_forward = decltype(
range)::is_forward;
579 static_assert(is_forward,
"adjacent_find requires ForwardIterators");
583 template <
class Range,
class BinaryPredicate>
585 is_range<Range>::value,
586 decltype(::std::begin(::core::forward<Range>(rng)))
589 static constexpr
auto is_forward = decltype(
range)::is_forward;
590 static_assert(is_forward,
"adjacent_find requires ForwardIterators");
594 ::core::forward<BinaryPredicate>(bp)
598 template <
class Range1,
class Range2>
600 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
601 decltype(::std::begin(::core::forward<Range1>(rng1)))
603 auto range1 =
make_range(::core::forward<Range1>(rng1));
604 auto range2 =
make_range(::core::forward<Range2>(rng2));
605 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
606 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
607 static_assert(is_forward1,
"search requires ForwardIterators");
608 static_assert(is_forward2,
"search requires ForwardIterators");
610 ::std::begin(range1),
612 ::std::begin(range2),
617 template <
class Range1,
class Range2,
class BinaryPred>
619 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
620 decltype(::std::begin(::core::forward<Range1>(rng1)))
622 auto range1 =
make_range(::core::forward<Range1>(rng1));
623 auto range2 =
make_range(::core::forward<Range2>(rng2));
624 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
625 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
626 static_assert(is_forward1,
"search requires ForwardIterators");
627 static_assert(is_forward2,
"search requires ForwardIterators");
629 ::std::begin(range1),
631 ::std::begin(range2),
633 ::core::forward<BinaryPred>(bp)
637 template <
class Range,
class Size,
class T>
639 is_range<Range>::value,
640 decltype(::std::begin(::core::forward<Range>(rng)))
643 static constexpr
auto is_forward = decltype(
range)::is_forward;
644 static_assert(is_forward,
"search_n requires ForwardIterators");
648 ::core::forward<Size>(
count),
653 template <
class Range,
class Size,
class T,
class BinaryPred>
660 is_range<Range>::value,
661 decltype(::std::begin(::core::forward<Range>(rng)))
664 static constexpr
auto is_forward = decltype(
range)::is_forward;
665 static_assert(is_forward,
"search_n requires ForwardIterators");
669 ::core::forward<Size>(
count),
671 ::core::forward<BinaryPred>(bp)
676 template <
class Range,
class OutputIt>
678 is_range<Range>::value,
682 static constexpr
auto is_input = decltype(
range)::is_input;
683 static_assert(is_input,
"copy requires InputIterators");
687 ::core::forward<OutputIt>(it)
691 template <
class Range,
class OutputIt,
class UnaryPredicate>
693 is_range<Range>::value,
697 static constexpr
auto is_input = decltype(
range)::is_input;
698 static_assert(is_input,
"copy_if requires InputIterators");
702 ::core::forward<OutputIt>(it),
703 ::core::forward<UnaryPredicate>(up)
707 template <
class Range,
class OutputIt,
class T>
710 static constexpr
auto is_input = decltype(
range)::is_input;
711 static_assert(is_input,
"copy_until requires InputIterators");
720 template <
class Range,
class B
idirIt>
722 is_range<Range>::value,
726 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
727 static_assert(is_bidir,
"copy_backward requires BidirectionalIterators");
731 ::core::forward<BidirIt>(it)
735 template <
class Range,
class OutputIt>
737 is_range<Range>::value,
741 static constexpr
auto is_input = decltype(
range)::is_input;
742 static_assert(is_input,
"move requires InputIterators");
746 ::core::forward<OutputIt>(it)
750 template <
class Range,
class B
idirIt>
752 is_range<Range>::value,
756 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
757 static_assert(is_bidir,
"move_backward requires BidirectionalIterators");
761 ::core::forward<BidirIt>(it)
765 template <
class Range,
class T>
767 is_range<Range>::value
770 static constexpr
auto is_forward = decltype(
range)::is_forward;
771 static_assert(is_forward,
"fill requires ForwardIterators");
775 template <
class Range,
class OutputIt,
class UnaryOperation>
781 is_range<Range>::value,
785 static constexpr
auto is_input = decltype(
range)::is_input;
786 static_assert(is_input,
"transform requires InputIterators");
790 ::core::forward<OutputIt>(it),
791 ::core::forward<UnaryOperation>(op)
795 template <
class Range,
class OutputIt,
class UnaryOperation,
class UnaryPred>
802 is_range<Range>::value,
806 static constexpr
auto is_forward = decltype(
range)::is_forward;
807 static_assert(is_forward,
"transform_if requires ForwardIterators");
818 template <
class InputIt,
class Size,
class OutputIt,
class UnaryOp>
843 *out =
invoke(op, *in1, *in2);
857 class BinaryOperation,
859 meta::all<is_range<Range>::value, meta::none<is_range<InputIt>::value>()>()
868 static constexpr
auto is_input = decltype(
range)::is_input;
869 static_assert(is_input,
"transform requires InputIterators");
873 ::core::forward<InputIt>(in),
874 ::core::forward<OutputIt>(out),
875 ::core::forward<BinaryOperation>(op));
882 class BinaryOperation,
884 meta::all_of<meta::list<Range1, Range2>,
is_range>()
892 auto range1 =
make_range(::core::forward<Range1>(rng1));
893 auto range2 =
make_range(::core::forward<Range2>(rng2));
894 static constexpr
auto is_input1 = decltype(range1)::is_input;
895 static constexpr
auto is_input2 = decltype(range2)::is_input;
896 static_assert(is_input1,
"transform requires InputIterators");
897 static_assert(is_input2,
"transform requires InputIterators");
899 ::std::begin(range1),
901 ::std::begin(range2),
902 ::core::forward<OutputIt>(it),
903 ::core::forward<BinaryOperation>(op)
911 class BinaryOperation,
912 class BinaryPredicate
920 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
923 auto range1 =
make_range(::core::forward<Range1>(rng1));
924 auto range2 =
make_range(::core::forward<Range2>(rng2));
925 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
926 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
927 static_assert(is_forward1,
"transform_if requires ForwardIterators");
928 static_assert(is_forward2,
"transform_if requires ForwardIterators");
929 while (not range1.empty()) {
930 if (bp(range1.front(), range2.front())) {
931 *it = op(range1.front(), range2.front());
940 template <
class Range,
class T>
942 is_range<Range>::value,
943 decltype(::std::begin(::core::forward<Range>(rng)))
946 static constexpr
auto is_forward = decltype(
range)::is_forward;
947 static_assert(is_forward,
"remove requires ForwardIterators");
951 template <
class Range,
class UnaryPredicate>
953 is_range<Range>::value,
954 decltype(::std::begin(::core::forward<Range>(rng)))
957 static constexpr
auto is_forward = decltype(
range)::is_forward;
958 static_assert(is_forward,
"remove_if requires ForwardIterators");
962 ::core::forward<UnaryPredicate>(up)
966 template <
class Range,
class OutputIt,
class T>
968 is_range<Range>::value,
972 static constexpr
auto is_input = decltype(
range)::is_input;
973 static_assert(is_input,
"remove_copy requires InputIterators");
977 ::core::forward<OutputIt>(it),
982 template <
class Range,
class OutputIt,
class UnaryPred>
984 is_range<Range>::value,
988 static constexpr
auto is_input = decltype(
range)::is_input;
989 static_assert(is_input,
"remove_copy_if requires InputIterators");
993 ::core::forward<OutputIt>(it),
994 ::core::forward<UnaryPred>(up)
998 template <
class Range,
class T>
1000 is_range<Range>::value
1002 ::core::forward<Range>(rng).erase(
1003 remove(::core::forward<Range>(rng), val),
1004 ::std::end(::core::forward<Range>(rng))
1008 template <
class Range,
class UnaryPred>
1010 is_range<Range>::value
1012 ::core::forward<Range>(rng).erase(
1014 ::core::forward<Range>(rng),
1015 ::core::forward<UnaryPred>(up)
1017 ::std::end(::core::forward<Range>(rng))
1021 template <
class Range,
class T>
1023 is_range<Range>::value
1026 static constexpr
auto is_forward = decltype(
range)::is_input;
1027 static_assert(is_forward,
"replace requires ForwardIterators");
1029 ::std::begin(
range),
1036 template <
class Range,
class UnaryPred,
class T>
1038 is_range<Range>::value
1041 static constexpr
auto is_forward = decltype(
range)::is_forward;
1042 static_assert(is_forward,
"replace_if requires ForwardIterators");
1044 ::std::begin(
range),
1046 ::core::forward<UnaryPred>(up),
1051 template <
class Range,
class OutputIt,
class T>
1058 is_range<Range>::value,
1062 static constexpr
auto is_input = decltype(
range)::is_input;
1063 static_assert(is_input,
"replace_copy requires InputIterators");
1065 ::std::begin(
range),
1067 ::core::forward<OutputIt>(it),
1073 template <
class Range,
class OutputIt,
class UnaryPred,
class T>
1080 is_range<Range>::value,
1084 static constexpr
auto is_input = decltype(
range)::is_input;
1085 static_assert(is_input,
"replace_copy_if requires InputIterators");
1087 ::std::begin(
range),
1089 ::core::forward<OutputIt>(it),
1090 ::core::forward<UnaryPred>(up),
1095 template <
class Range,
class ForwardIt>
1097 is_range<Range>::value,
1101 static constexpr
auto is_forward = decltype(
range)::is_forward;
1102 static_assert(is_forward,
"swap_ranges requires ForwardIterators");
1104 ::std::begin(
range),
1106 ::core::forward<ForwardIt>(it)
1110 template <
class Range>
1113 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
1114 static_assert(is_bidir,
"reverse requires BidirectionalIterators");
1118 template <
class Range,
class OutputIt>
1120 is_range<Range>::value,
1124 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
1125 static_assert(is_bidir,
"reverse_copy requires BidirectionalIterators");
1127 ::std::begin(
range),
1129 ::core::forward<OutputIt>(it)
1133 template <
class Range,
class ForwardIt>
1135 is_range<Range>::value
1138 static constexpr
auto is_forward = decltype(
range)::is_forward;
1139 static_assert(is_forward,
"rotate requires ForwardIterators");
1141 ::std::begin(
range),
1142 ::core::forward<ForwardIt>(it),
1147 template <
class Range,
class ForwardIt,
class OutputIt>
1149 is_range<Range>::value,
1153 static constexpr
auto is_forward = decltype(
range)::is_forward;
1154 static_assert(is_forward,
"rotate_copy requires ForwardIterators");
1156 ::std::begin(
range),
1157 ::core::forward<ForwardIt>(it),
1159 ::core::forward<OutputIt>(ot)
1163 template <
class Range,
class URNG>
1165 is_range<Range>::value
1168 static constexpr
auto is_random = decltype(
range)::is_random_access;
1169 static_assert(is_random,
"shuffle requires RandomAccessIterators");
1171 ::std::begin(
range),
1173 ::core::forward<URNG>(g)
1177 template <
class Range>
1179 is_range<Range>::value,
1180 decltype(::std::begin(::core::forward<Range>(rng)))
1183 static constexpr
auto is_forward = decltype(
range)::is_forward;
1184 static_assert(is_forward,
"unique requires ForwardIterators");
1188 template <
class Range,
class BinaryPredicate>
1190 is_range<Range>::value,
1191 decltype(::std::begin(::core::forward<Range>(rng)))
1194 static constexpr
auto is_forward = decltype(
range)::is_forward;
1195 static_assert(is_forward,
"unique requires ForwardIterators");
1197 ::std::begin(
range),
1199 ::core::forward<BinaryPredicate>(bp)
1203 template <
class Range,
class OutputIt>
1205 is_range<Range>::value,
1209 static constexpr
auto is_input = decltype(
range)::is_input;
1210 static_assert(is_input,
"unique_copy requires InputIterators");
1212 ::std::begin(
range),
1214 ::core::forward<OutputIt>(it)
1218 template <
class Range,
class OutputIt,
class BinaryPred>
1220 is_range<Range>::value,
1224 static constexpr
auto is_input = decltype(
range)::is_input;
1225 static_assert(is_input,
"unique_copy requires InputIterators");
1227 ::std::begin(
range),
1229 ::core::forward<OutputIt>(it),
1230 ::core::forward<BinaryPred>(bp)
1235 template <
class Range,
class UnaryPredicate>
1237 is_range<Range>::value,
1241 static constexpr
auto is_input = decltype(
range)::is_input;
1242 static_assert(is_input,
"is_partitioned requires InputIterators");
1244 ::std::begin(
range),
1246 ::core::forward<UnaryPredicate>(up)
1250 template <
class Range,
class UnaryPredicate>
1252 is_range<Range>::value,
1253 decltype(::std::begin(::core::forward<Range>(rng)))
1256 static constexpr
auto is_forward = decltype(
range)::is_forward;
1257 static_assert(is_forward,
"partition requires ForwardIterators");
1259 ::std::begin(
range),
1261 ::core::forward<UnaryPredicate>(up)
1265 template <
class Range,
class OutputTrue,
class OutputFalse,
class UnaryPred>
1272 is_range<Range>::value,
1276 static constexpr
auto is_input = decltype(
range)::is_input;
1277 static_assert(is_input,
"partition_copy requires InputIterators");
1279 ::std::begin(
range),
1281 ::core::forward<OutputTrue>(ot),
1282 ::core::forward<OutputFalse>(of),
1283 ::core::forward<UnaryPred>(up)
1287 template <
class Range,
class UnaryPredicate>
1289 is_range<Range>::value,
1290 decltype(::std::begin(::core::forward<Range>(rng)))
1293 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
1294 static_assert(is_bidir,
"stable_partition requires BidirectionalIterators");
1296 ::std::begin(
range),
1298 ::core::forward<UnaryPredicate>(up)
1302 template <
class Range,
class UnaryPredicate>
1304 is_range<Range>::value,
1305 decltype(::std::begin(::core::forward<Range>(rng)))
1308 static constexpr
auto is_forward = decltype(
range)::is_forward;
1309 static_assert(is_forward,
"partition_point requires ForwardIterators");
1311 ::std::begin(
range),
1313 ::core::forward<UnaryPredicate>(up)
1319 template <
class Range>
1322 static constexpr
auto is_forward = decltype(
range)::is_forward;
1323 static_assert(is_forward,
"is_sorted requires ForwardIterators");
1327 template <
class Range,
class Compare>
1329 is_range<Range>::value,
1333 static constexpr
auto is_forward = decltype(
range)::is_forward;
1334 static_assert(is_forward,
"is_sorted requires ForwardIterators");
1336 ::std::begin(
range),
1338 ::core::forward<Compare>(compare)
1342 template <
class Range>
1344 is_range<Range>::value,
1345 decltype(::std::begin(::core::forward<Range>(rng)))
1348 static constexpr
auto is_forward = decltype(
range)::is_forward;
1349 static_assert(is_forward,
"is_sorted_until requires ForwardIterators");
1353 template <
class Range,
class Compare>
1355 is_range<Range>::value,
1356 decltype(::std::begin(::core::forward<Range>(rng)))
1359 static constexpr
auto is_forward = decltype(
range)::is_forward;
1360 static_assert(is_forward,
"is_sorted_until requires ForwardIterators");
1362 ::std::begin(
range),
1364 ::core::forward<Compare>(compare)
1368 template <
class Range>
1371 static constexpr
auto is_random = decltype(
range)::is_random_access;
1372 static_assert(is_random,
"sort requires RandomAccessIterators");
1376 template <
class Range,
class Compare>
1379 static constexpr
auto is_random = decltype(
range)::is_random_access;
1380 static_assert(is_random,
"sort requires RandomAccessIterators");
1382 ::std::begin(
range),
1384 ::core::forward<Compare>(cmp)
1388 template <
class Range,
class RandomIt>
1390 is_range<Range>::value
1393 static constexpr
auto is_random = decltype(
range)::is_random_access;
1394 static_assert(is_random,
"partial_sort requires RandomAccessIterators");
1396 ::std::begin(
range),
1397 ::core::forward<RandomIt>(it),
1402 template <
class Range,
class RandomIt,
class Compare>
1404 is_range<Range>::value
1407 static constexpr
auto is_random = decltype(
range)::is_random_access;
1408 static_assert(is_random,
"partial_sort requires RandomAccessIterators");
1410 ::std::begin(
range),
1411 ::core::forward<RandomIt>(it),
1413 ::core::forward<Compare>(cmp)
1417 template <
class IRange,
class RRange>
1419 meta::all_of<meta::list<IRange, RRange>,
is_range>(),
1420 decltype(::std::begin(::core::forward<RRange>(rrng)))
1422 auto irange =
make_range(::core::forward<IRange>(irng));
1423 auto rrange =
make_range(::core::forward<RRange>(rrng));
1424 static constexpr
auto is_input = decltype(irange)::is_input;
1425 static constexpr
auto is_random = decltype(rrange)::is_random_access;
1426 static_assert(is_input,
"partial_sort_copy requires InputIterators");
1427 static_assert(is_random,
"partial_sort_copy requires RandomAccessIterators");
1429 ::std::begin(irange),
1431 ::std::begin(rrange),
1436 template <
class IRange,
class RRange,
class Compare>
1442 meta::all_of<meta::list<IRange, RRange>,
is_range>(),
1443 decltype(::std::begin(::core::forward<RRange>(rrng)))
1445 auto irange =
make_range(::core::forward<IRange>(irng));
1446 auto rrange =
make_range(::core::forward<RRange>(rrng));
1447 static constexpr
auto is_input = decltype(irange)::is_input;
1448 static constexpr
auto is_random = decltype(rrange)::is_random_access;
1449 static_assert(is_input,
"partial_sort_copy requires InputIterators");
1450 static_assert(is_random,
"partial_sort_copy requires RandomAccessIterators");
1452 ::std::begin(irange),
1454 ::std::begin(rrange),
1456 ::core::forward<Compare>(cmp)
1460 template <
class Range>
1463 static constexpr
auto is_random = decltype(
range)::is_random_access;
1464 static_assert(is_random,
"stable_sort requires RandomAccessIterators");
1468 template <
class Range,
class Compare>
1470 is_range<Range>::value
1473 static constexpr
auto is_random = decltype(
range)::is_random_access;
1474 static_assert(is_random,
"stable_sort requires RandomAccessIterators");
1476 ::std::begin(
range),
1478 ::core::forward<Compare>(cmp)
1482 template <
class Range,
class RandomIt>
1484 is_range<Range>::value
1487 static constexpr
auto is_random = decltype(
range)::is_random_access;
1488 static_assert(is_random,
"nth_element requires RandomAccessIterators");
1490 ::std::begin(
range),
1491 ::core::forward<RandomIt>(it),
1496 template <
class Range,
class RandomIt,
class Compare>
1498 is_range<Range>::value
1501 static constexpr
auto is_random = decltype(
range)::is_random_access;
1502 static_assert(is_random,
"nth_element requires RandomAccessIterators");
1504 ::std::begin(
range),
1505 ::core::forward<RandomIt>(it),
1507 ::core::forward<Compare>(cmp)
1512 template <
class Range,
class T>
1514 is_range<Range>::value,
1515 decltype(::std::begin(::core::forward<Range>(rng)))
1518 static constexpr
auto is_forward = decltype(
range)::is_forward;
1519 static_assert(is_forward,
"lower_bound requires ForwardIterators");
1523 template <
class Range,
class T,
class Compare>
1525 is_range<Range>::value,
1526 decltype(::std::begin(::core::forward<Range>(rng)))
1529 static constexpr
auto is_forward = decltype(
range)::is_forward;
1530 static_assert(is_forward,
"lower_bound requires ForwardIterators");
1532 ::std::begin(
range),
1535 ::core::forward<Compare>(cmp)
1539 template <
class Range,
class T>
1541 is_range<Range>::value,
1542 decltype(::std::begin(::core::forward<Range>(rng)))
1545 static constexpr
auto is_forward = decltype(
range)::is_forward;
1546 static_assert(is_forward,
"upper_bound requires ForwardIterators");
1550 template <
class Range,
class T,
class Compare>
1552 is_range<Range>::value,
1553 decltype(::std::begin(::core::forward<Range>(rng)))
1556 static constexpr
auto is_forward = decltype(
range)::is_forward;
1557 static_assert(is_forward,
"upper_bound requires ForwardIterators");
1559 ::std::begin(
range),
1562 ::core::forward<Compare>(cmp)
1566 template <
class Range,
class T>
1568 is_range<Range>::value,
1572 static constexpr
auto is_forward = decltype(
range)::is_forward;
1573 static_assert(is_forward,
"binary_search requires ForwardIterators");
1577 template <
class Range,
class T,
class Compare>
1579 is_range<Range>::value,
1583 static constexpr
auto is_forward = decltype(
range)::is_forward;
1584 static_assert(is_forward,
"binary_search requires ForwardIterators");
1586 ::std::begin(
range),
1589 ::core::forward<Compare>(cmp)
1593 template <
class Range,
class T>
1595 is_range<Range>::value,
1599 static constexpr
auto is_forward = decltype(
range)::is_forward;
1600 static_assert(is_forward,
"equal_range requires ForwardIterators");
1604 template <
class Range,
class T,
class Compare>
1606 is_range<Range>::value,
1610 static constexpr
auto is_forward = decltype(
range)::is_forward;
1611 static_assert(is_forward,
"equal_range requires ForwardIterators");
1613 ::std::begin(
range),
1616 ::core::forward<Compare>(cmp)
1621 template <
class Range1,
class Range2,
class OutputIt>
1623 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1626 auto range1 =
make_range(::core::forward<Range1>(rng1));
1627 auto range2 =
make_range(::core::forward<Range2>(rng2));
1628 static constexpr
auto is_input1 = decltype(range1)::is_input;
1629 static constexpr
auto is_input2 = decltype(range2)::is_input;
1630 static_assert(is_input1,
"merge requires InputIterators");
1631 static_assert(is_input2,
"merge requires InputIterators");
1633 ::std::begin(range1),
1635 ::std::begin(range2),
1637 ::core::forward<OutputIt>(it)
1641 template <
class Range1,
class Range2,
class OutputIt,
class Compare>
1648 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1651 auto range1 =
make_range(::core::forward<Range1>(rng1));
1652 auto range2 =
make_range(::core::forward<Range2>(rng2));
1653 static constexpr
auto is_input1 = decltype(range1)::is_input;
1654 static constexpr
auto is_input2 = decltype(range2)::is_input;
1655 static_assert(is_input1,
"merge requires InputIterators");
1656 static_assert(is_input2,
"merge requires InputIterators");
1658 ::std::begin(range1),
1660 ::std::begin(range2),
1662 ::core::forward<OutputIt>(it),
1663 ::core::forward<Compare>(cmp)
1667 template <
class Range,
class B
idirIt>
1669 is_range<Range>::value
1672 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
1673 static_assert(is_bidir,
"inplace_merge requires BidirectionalIterators");
1675 ::std::begin(
range),
1676 ::core::forward<BidirIt>(it),
1681 template <
class Range,
class B
idirIt,
class Compare>
1683 is_range<Range>::value
1686 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
1687 static_assert(is_bidir,
"inplace_merge requires BidirectionalIterators");
1689 ::std::begin(
range),
1690 ::core::forward<BidirIt>(it),
1692 ::core::forward<Compare>(cmp)
1696 template <
class Range1,
class Range2>
1698 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1701 auto range1 =
make_range(::core::forward<Range1>(rng1));
1702 auto range2 =
make_range(::core::forward<Range2>(rng2));
1703 static constexpr
auto is_input1 = decltype(range1)::is_input;
1704 static constexpr
auto is_input2 = decltype(range2)::is_input;
1705 static_assert(is_input1,
"includes requires InputIterators");
1706 static_assert(is_input2,
"includes requires InputIterators");
1708 ::std::begin(range1),
1710 ::std::begin(range2),
1715 template <
class Range1,
class Range2,
class Compare>
1717 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1720 auto range1 =
make_range(::core::forward<Range1>(rng1));
1721 auto range2 =
make_range(::core::forward<Range2>(rng2));
1722 static constexpr
auto is_input1 = decltype(range1)::is_input;
1723 static constexpr
auto is_input2 = decltype(range2)::is_input;
1724 static_assert(is_input1,
"includes requires InputIterators");
1725 static_assert(is_input2,
"includes requires InputIterators");
1727 ::std::begin(range1),
1729 ::std::begin(range2),
1731 ::core::forward<Compare>(cmp)
1735 template <
class Range1,
class Range2,
class OutputIt>
1737 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1740 auto range1 =
make_range(::core::forward<Range1>(rng1));
1741 auto range2 =
make_range(::core::forward<Range2>(rng2));
1742 static constexpr
auto is_input1 = decltype(range1)::is_input;
1743 static constexpr
auto is_input2 = decltype(range2)::is_input;
1744 static_assert(is_input1,
"set_difference requires InputIterators");
1745 static_assert(is_input2,
"set_difference requires InputIterators");
1747 ::std::begin(range1),
1749 ::std::begin(range2),
1751 ::core::forward<OutputIt>(it)
1755 template <
class Range1,
class Range2,
class OutputIt,
class Compare>
1762 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1765 auto range1 =
make_range(::core::forward<Range1>(rng1));
1766 auto range2 =
make_range(::core::forward<Range2>(rng2));
1767 static constexpr
auto is_input1 = decltype(range1)::is_input;
1768 static constexpr
auto is_input2 = decltype(range2)::is_input;
1769 static_assert(is_input1,
"set_difference requires InputIterators");
1770 static_assert(is_input2,
"set_difference requires InputIterators");
1772 ::std::begin(range1),
1774 ::std::begin(range2),
1776 ::core::forward<OutputIt>(it),
1777 ::core::forward<Compare>(cmp)
1781 template <
class Range1,
class Range2,
class OutputIt>
1783 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1786 auto range1 =
make_range(::core::forward<Range1>(rng1));
1787 auto range2 =
make_range(::core::forward<Range2>(rng2));
1788 static constexpr
auto is_input1 = decltype(range1)::is_input;
1789 static constexpr
auto is_input2 = decltype(range2)::is_input;
1790 static_assert(is_input1,
"set_intersection requires InputIterators");
1791 static_assert(is_input2,
"set_intersection requires InputIterators");
1793 ::std::begin(range1),
1795 ::std::begin(range2),
1797 ::core::forward<OutputIt>(it)
1801 template <
class Range1,
class Range2,
class OutputIt,
class Compare>
1808 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1811 auto range1 =
make_range(::core::forward<Range1>(rng1));
1812 auto range2 =
make_range(::core::forward<Range2>(rng2));
1813 static constexpr
auto is_input1 = decltype(range1)::is_input;
1814 static constexpr
auto is_input2 = decltype(range2)::is_input;
1815 static_assert(is_input1,
"set_intersection requires InputIterators");
1816 static_assert(is_input2,
"set_intersection requires InputIterators");
1818 ::std::begin(range1),
1820 ::std::begin(range2),
1822 ::core::forward<OutputIt>(it),
1823 ::core::forward<Compare>(cmp)
1827 template <
class Range1,
class Range2,
class OutputIt>
1829 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1832 auto range1 =
make_range(::core::forward<Range1>(rng1));
1833 auto range2 =
make_range(::core::forward<Range2>(rng2));
1834 static constexpr
auto is_input1 = decltype(range1)::is_input;
1835 static constexpr
auto is_input2 = decltype(range2)::is_input;
1836 static_assert(is_input1,
"set_symmetric_difference requires InputIterators");
1837 static_assert(is_input2,
"set_symmetric_difference requires InputIterators");
1839 ::std::begin(range1),
1841 ::std::begin(range2),
1843 ::core::forward<OutputIt>(it)
1847 template <
class Range1,
class Range2,
class OutputIt,
class Compare>
1854 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1857 auto range1 =
make_range(::core::forward<Range1>(rng1));
1858 auto range2 =
make_range(::core::forward<Range2>(rng2));
1859 static constexpr
auto is_input1 = decltype(range1)::is_input;
1860 static constexpr
auto is_input2 = decltype(range2)::is_input;
1861 static_assert(is_input1,
"set_symmetric_difference requires InputIterators");
1862 static_assert(is_input2,
"set_symmetric_difference requires InputIterators");
1864 ::std::begin(range1),
1866 ::std::begin(range2),
1868 ::core::forward<OutputIt>(it),
1869 ::core::forward<Compare>(cmp)
1873 template <
class Range1,
class Range2,
class OutputIt>
1875 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1878 auto range1 =
make_range(::core::forward<Range1>(rng1));
1879 auto range2 =
make_range(::core::forward<Range2>(rng2));
1880 static constexpr
auto is_input1 = decltype(range1)::is_input;
1881 static constexpr
auto is_input2 = decltype(range2)::is_input;
1882 static_assert(is_input1,
"set_union requires InputIterators");
1883 static_assert(is_input2,
"set_union requires InputIterators");
1885 ::std::begin(range1),
1887 ::std::begin(range2),
1889 ::core::forward<OutputIt>(it)
1893 template <
class Range1,
class Range2,
class OutputIt,
class Compare>
1900 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
1903 auto range1 =
make_range(::core::forward<Range1>(rng1));
1904 auto range2 =
make_range(::core::forward<Range2>(rng2));
1905 static constexpr
auto is_input1 = decltype(range1)::is_input;
1906 static constexpr
auto is_input2 = decltype(range2)::is_input;
1907 static_assert(is_input1,
"set_union requires InputIterators");
1908 static_assert(is_input2,
"set_union requires InputIterators");
1910 ::std::begin(range1),
1912 ::std::begin(range2),
1914 ::core::forward<OutputIt>(it),
1915 ::core::forward<Compare>(cmp)
1920 template <
class Range>
1923 static constexpr
auto is_random = decltype(
range)::is_random_access;
1924 static_assert(is_random,
"is_heap requires RandomAccessIterators");
1928 template <
class Range,
class Compare>
1930 is_range<Range>::value,
1934 static constexpr
auto is_random = decltype(
range)::is_random_access;
1935 static_assert(is_random,
"is_heap requires RandomAccessIterators");
1937 ::std::begin(
range),
1939 ::core::forward<Compare>(cmp)
1943 template <
class Range>
1945 is_range<Range>::value,
1946 decltype(::std::begin(::core::forward<Range>(rng)))
1949 static constexpr
auto is_random = decltype(
range)::is_random_access;
1950 static_assert(is_random,
"is_heap_until requires RandomAccessIterators");
1954 template <
class Range,
class Compare>
1956 is_range<Range>::value,
1957 decltype(::std::begin(::core::forward<Range>(rng)))
1960 static constexpr
auto is_random = decltype(
range)::is_random_access;
1961 static_assert(is_random,
"is_heap_until requires RandomAccessIterators");
1963 ::std::begin(
range),
1965 ::core::forward<Compare>(cmp)
1969 template <
class Range>
1972 static constexpr
auto is_random = decltype(
range)::is_random_access;
1973 static_assert(is_random,
"make_heap requires RandomAccessIterators");
1977 template <
class Range,
class Compare>
1979 is_range<Range>::value
1982 static constexpr
auto is_random = decltype(
range)::is_random_access;
1983 static_assert(is_random,
"make_heap requires RandomAccessIterators");
1985 ::std::begin(
range),
1987 ::core::forward<Compare>(cmp)
1991 template <
class Range>
1994 static constexpr
auto is_random = decltype(
range)::is_random_access;
1995 static_assert(is_random,
"push_heap requires RandomAccessIterators");
1999 template <
class Range,
class Compare>
2001 is_range<Range>::value
2004 static constexpr
auto is_random = decltype(
range)::is_random_access;
2005 static_assert(is_random,
"push_heap requires RandomAccessIterators");
2007 ::std::begin(
range),
2009 ::core::forward<Compare>(cmp)
2013 template <
class Range>
2016 static constexpr
auto is_random = decltype(
range)::is_random_access;
2017 static_assert(is_random,
"pop_heap requires RandomAccessIterators");
2021 template <
class Range,
class Compare>
2023 is_range<Range>::value
2026 static constexpr
auto is_random = decltype(
range)::is_random_access;
2027 static_assert(is_random,
"pop_heap requires RandomAccessIterators");
2029 ::std::begin(
range),
2031 ::core::forward<Compare>(cmp)
2035 template <
class Range>
2038 static constexpr
auto is_random = decltype(
range)::is_random_access;
2039 static_assert(is_random,
"sort_heap requires RandomAccessIterators");
2043 template <
class Range,
class Compare>
2045 is_range<Range>::value
2048 static constexpr
auto is_random = decltype(
range)::is_random_access;
2049 static_assert(is_random,
"sort_heap requires RandomAccessIterators");
2051 ::std::begin(
range),
2053 ::core::forward<Compare>(cmp)
2058 template <
class Range>
2060 is_range<Range>::value,
2061 decltype(::std::begin(::core::forward<Range>(rng)))
2064 static constexpr
auto is_forward = decltype(
range)::is_forward;
2065 static_assert(is_forward,
"max_element requires ForwardIterators");
2069 template <
class Range,
class Compare>
2071 is_range<Range>::value,
2072 decltype(::std::begin(::core::forward<Range>(rng)))
2075 static constexpr
auto is_forward = decltype(
range)::is_forward;
2076 static_assert(is_forward,
"max_element requires ForwardIterators");
2078 ::std::begin(
range),
2080 ::core::forward<Compare>(cmp)
2084 template <
class Range>
2086 is_range<Range>::value,
2087 decltype(::std::begin(::core::forward<Range>(rng)))
2090 static constexpr
auto is_forward = decltype(
range)::is_forward;
2091 static_assert(is_forward,
"min_element requires ForwardIterators");
2095 template <
class Range,
class Compare>
2097 is_range<Range>::value,
2098 decltype(::std::begin(::core::forward<Range>(rng)))
2101 static constexpr
auto is_forward = decltype(
range)::is_forward;
2102 static_assert(is_forward,
"min_element requires ForwardIterators");
2104 ::std::begin(
range),
2106 ::core::forward<Compare>(cmp)
2110 template <
class Range>
2112 is_range<Range>::value,
2114 decltype(::std::begin(::core::forward<Range>(rng))),
2115 decltype(::std::end(::core::forward<Range>(rng)))
2119 static constexpr
auto is_forward = decltype(
range)::is_forward;
2120 static_assert(is_forward,
"minmax_element requires ForwardIterators");
2124 template <
class Range,
class Compare>
2126 is_range<Range>::value,
2129 range<decltype(::std::end(::core::forward<Range>(rng)))>
2133 static constexpr
auto is_forward = decltype(
range)::is_forward;
2134 static_assert(is_forward,
"minmax_element requires ForwardIterators");
2136 ::std::begin(
range),
2138 ::core::forward<Compare>(cmp)
2142 template <
class Range1,
class Range2>
2144 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
2147 auto range1 =
make_range(::core::forward<Range1>(rng1));
2148 auto range2 =
make_range(::core::forward<Range2>(rng2));
2149 static constexpr
auto is_input1 = decltype(range1)::is_input;
2150 static constexpr
auto is_input2 = decltype(range2)::is_input;
2151 static_assert(is_input1,
"lexicographical_compare requires InputIterators");
2152 static_assert(is_input2,
"lexicographical_compare requires InputIterators");
2154 ::std::begin(range1),
2156 ::std::begin(range2),
2161 template <
class Range1,
class Range2,
class Compare>
2167 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
2170 auto range1 =
make_range(::core::forward<Range1>(rng1));
2171 auto range2 =
make_range(::core::forward<Range2>(rng2));
2172 static constexpr
auto is_input1 = decltype(range1)::is_input;
2173 static constexpr
auto is_input2 = decltype(range2)::is_input;
2174 static_assert(is_input1,
"lexicographical_compare requires InputIterators");
2175 static_assert(is_input2,
"lexicographical_compare requires InputIterators");
2177 ::std::begin(range1),
2179 ::std::begin(range2),
2181 ::core::forward<Compare>(cmp)
2185 template <
class Range1,
class Range2>
2187 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
2190 auto range1 =
make_range(::core::forward<Range1>(rng1));
2191 auto range2 =
make_range(::core::forward<Range2>(rng2));
2192 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
2193 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
2194 static_assert(is_forward1,
"is_permutation requires ForwardIterators");
2195 static_assert(is_forward2,
"is_permutation requires ForwardIterators");
2197 ::std::begin(range1),
2199 ::std::begin(range2)
2203 template <
class Range1,
class Range2,
class BinaryPredicate>
2207 BinaryPredicate&& bp
2209 meta::all_of<meta::list<Range1, Range2>,
is_range>(),
2212 auto range1 =
make_range(::core::forward<Range1>(rng1));
2213 auto range2 =
make_range(::core::forward<Range2>(rng2));
2214 static constexpr
auto is_forward1 = decltype(range1)::is_forward;
2215 static constexpr
auto is_forward2 = decltype(range2)::is_forward;
2216 static_assert(is_forward1,
"is_permutation requires ForwardIterators");
2217 static_assert(is_forward2,
"is_permutation requires ForwardIterators");
2219 ::std::begin(range1),
2221 ::std::begin(range2),
2222 ::core::forward<BinaryPredicate>(bp)
2226 template <
class Range>
2228 is_range<Range>::value,
2232 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
2233 static_assert(is_bidir,
"next_permutation requires BidirectionalIterators");
2237 template <
class Range,
class Compare>
2239 is_range<Range>::value,
2243 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
2244 static_assert(is_bidir,
"next_permutation requires BidirectionalIterators");
2246 ::std::begin(
range),
2248 ::core::forward<Compare>(cmp)
2252 template <
class Range>
2254 is_range<Range>::value,
2258 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
2259 static_assert(is_bidir,
"prev_permutation requires BidirectionalIterators");
2263 template <
class Range,
class Compare>
2265 is_range<Range>::value,
2269 static constexpr
auto is_bidir = decltype(
range)::is_bidirectional;
2270 static_assert(is_bidir,
"prev_permutation requires BidirectionalIterators");
2272 ::std::begin(
range),
2274 ::core::forward<Compare>(cmp)
auto make_heap(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
auto is_sorted_until(Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto replace(Range &&rng, T const &old, T const &value) -> enable_if_t< is_range< Range >::value >
auto adjacent_find(Range &&rng, BinaryPredicate &&bp) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto lexicographical_compare(Range1 &&rng1, Range2 &&rng2) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
auto unique(Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto rotate(Range &&rng, ForwardIt &&it) -> enable_if_t< is_range< Range >::value >
auto for_each(Range &&rng, UnaryFunction &&f) -> enable_if_t< is_range< Range >::value, decay_t< UnaryFunction > >
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 > >
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 > >
auto all_of(Range &&rng, UnaryPredicate &&p) -> meta::when< is_range< Range >::value, bool >
auto remove_copy(Range &&rng, OutputIt &&it, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto remove_if(Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
void pop_front(difference_type n)
auto prev_permutation(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
::std::pair< InputIt1, InputIt2 > mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate predicate)
auto make_range(T *ptr, ::std::size_t n) -> range< T *>
auto stable_sort(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
auto stable_sort(Range &&rng) -> enable_if_t< is_range< Range >::value >
auto find_if(Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto replace_copy(Range &&rng, OutputIt &&it, T const &old, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
Copyright © 2013 - 2015 MNMLSTC.
auto nth_element(Range &&rng, RandomIt &&it) -> enable_if_t< is_range< Range >::value >
auto unique_copy(Range &&rng, OutputIt &&it, BinaryPred &&bp) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto inplace_merge(Range &&rng, BidirIt &&it, Compare &&cmp) -> meta::when< is_range< Range >::value >
auto inplace_merge(Range &&rng, BidirIt &&it) -> meta::when< is_range< Range >::value >
auto search_n(Range &&rng, Size &&count, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto invoke(Functor &&f, Args &&... args) -> enable_if_t< ::std::is_member_pointer< decay_t< Functor >>::value, result_of_t< Functor &&(Args &&...)> >
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))
auto is_heap(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
auto find_if_not(Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto max_element(Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
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))) >
auto move_backward(Range &&rng, BidirIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< BidirIt > >
auto any_of(Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, bool >
auto pop_heap(Range &&rng) -> enable_if_t< is_range< Range >::value >
auto adjacent_find(Range &&rng) -> meta::when< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
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))) >
auto sort(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
constexpr T const & max(T const &lhs, T const &rhs)
auto max_element(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
UnaryFunction for_each_if(Range &&r, UnaryFunction uf, UnaryPredicate up)
auto sort_heap(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
auto fill(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value >
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))) >
auto prev_permutation(Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
RangeType< double > Range
3.0.0 TODO: break reverse-compatibility by changing RangeType to Range.
auto next_permutation(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
auto includes(Range1 &&rng1, Range2 &&rng2, Compare &&cmp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
auto transform(Range &&rng, OutputIt &&it, UnaryOperation &&op) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto replace_if(Range &&rng, UnaryPred &&up, T const &value) -> enable_if_t< is_range< Range >::value >
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 > >
bool equal(Range &&rng, InputIt &&it, BinaryPredicate &&bp)
auto binary_search(Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, bool >
auto min_element(Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto reverse(Range &&rng) -> enable_if_t< is_range< Range >::value >
auto lower_bound(Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto remove_erase(Range &&rng, T const &val) -> enable_if_t< is_range< Range >::value >
auto partial_sort(Range &&rng, RandomIt &&it) -> enable_if_t< is_range< Range >::value >
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))) >
auto sort(Range &&rng) -> enable_if_t< is_range< Range >::value >
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))) >
auto unique_copy(Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
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 > >
auto for_each_until(Range &&r, UnaryFunction f, T const &value) -> decltype(begin(make_range(::core::forward< Range >(r))))
auto set_intersection(Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
OutputIt copy_until(Range &&r, OutputIt it, T const &value)
auto transform_if(Range &&rng, OutputIt it, UnaryOperation op, UnaryPred up) -> enable_if_t< is_range< Range >::value, OutputIt >
auto lexicographical_compare(Range1 &&rng1, Range2 &&rng2, Compare &&cmp) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
auto binary_search(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, bool >
auto is_partitioned(Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, bool >
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 > >
auto next_permutation(Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
auto remove(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto search(Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decltype(::std::begin(::core::forward< Range1 >(rng1))) >
auto is_heap_until(Range &&rng) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto find(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
difference_type size() const
auto is_sorted_until(Range &&rng, Compare &&compare) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto nth_element(Range &&rng, RandomIt &&it, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
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)))> >
auto remove_erase_if(Range &&rng, UnaryPred &&up) -> enable_if_t< is_range< Range >::value >
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 >> >
auto copy(Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto make_heap(Range &&rng) -> enable_if_t< is_range< Range >::value >
bool equal(range< InputIt1 > r1, range< InputIt2 > r2, Predicate &&p, ::std::random_access_iterator_tag, ::std::random_access_iterator_tag)
auto pop_heap(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
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))) > >
auto is_heap(Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
auto is_sorted(Range &&rng, Compare &&compare) -> enable_if_t< is_range< Range >::value, bool >
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 > >
decay_t< OutputIt > transform(Range1 &&rng1, Range2 &&rng2, OutputIt &&it, BinaryOperation &&op)
auto rotate_copy(Range &&rng, ForwardIt &&it, OutputIt &&ot) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto reverse_copy(Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto upper_bound(Range &&rng, T const &value, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto partition(Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
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))) >
auto is_permutation(Range1 &&rng1, Range2 &&rng2, BinaryPredicate &&bp) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
auto mismatch(Range &&r, InputIt &&it, BinaryPredicate &&bp) -> ::std::pair< decltype(core::make_range(::core::forward< Range >(r).begin())), decay_t< InputIt > >
auto min_element(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto remove_copy_if(Range &&rng, OutputIt &&it, UnaryPred &&up) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto partial_sort(Range &&rng, RandomIt &&it, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
auto shuffle(Range &&rng, URNG &&g) -> enable_if_t< is_range< Range >::value >
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)) >
auto copy_if(Range &&rng, OutputIt &&it, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
constexpr T const & clamp(T const &value, T const &low, T const &high, Compare compare=Compare { })
impl::decay_t< T > decay_t
constexpr T const & min(T const &lhs, T const &rhs)
auto includes(Range1 &&rng1, Range2 &&rng2) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
typename ::std::enable_if< B, T >::type enable_if_t
auto set_union(Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
OutputIt transform_n(InputIt in, Size count, OutputIt out, UnaryOp op)
auto equal_range(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, range< decltype(::std::begin(::core::forward< Range >(rng)))> >
auto set_difference(Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
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))) >
auto replace_copy_if(Range &&rng, OutputIt &&it, UnaryPred &&up, T const &value) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto push_heap(Range &&rng) -> enable_if_t< is_range< Range >::value >
auto is_sorted(Range &&rng) -> enable_if_t< is_range< Range >::value, bool >
auto move(Range &&rng, OutputIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< OutputIt > >
auto sort_heap(Range &&rng) -> enable_if_t< is_range< Range >::value >
auto is_permutation(Range1 &&rng1, Range2 &&rng2) -> enable_if_t< meta::all_of< meta::list< Range1, Range2 >, is_range >(), bool >
auto is_heap_until(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto merge(Range1 &&rng1, Range2 &&rng2, OutputIt &&it) -> meta::when< meta::all_of< meta::list< Range1, Range2 >, is_range >(), decay_t< OutputIt > >
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))) >
auto unique(Range &&rng, BinaryPredicate &&bp) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto lower_bound(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
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))) >
auto stable_partition(Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto none_of(Range &&rng, UnaryPredicate &&p) -> enable_if_t< is_range< Range >::value, bool >
auto swap_ranges(Range &&rng, ForwardIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< ForwardIt > >
auto upper_bound(Range &&rng, T const &value) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >
auto for_each_while(Range &&r, UnaryFunction f, UnaryPredicate p) -> decltype(begin(make_range(::core::forward< Range >(r))))
auto push_heap(Range &&rng, Compare &&cmp) -> enable_if_t< is_range< Range >::value >
auto copy_backward(Range &&rng, BidirIt &&it) -> enable_if_t< is_range< Range >::value, decay_t< BidirIt > >
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)))> > >
auto partition_point(Range &&rng, UnaryPredicate &&up) -> enable_if_t< is_range< Range >::value, decltype(::std::begin(::core::forward< Range >(rng))) >