31 #ifndef ETL_ALGORITHM_INCLUDED
32 #define ETL_ALGORITHM_INCLUDED
61 template <
typename TIterator>
62 void shell_sort(TIterator first, TIterator last);
64 template <
typename TIterator,
typename TCompare>
65 void shell_sort(TIterator first, TIterator last, TCompare compare);
67 template <
typename TIterator>
70 template <
typename TIterator,
typename TCompare>
71 void insertion_sort(TIterator first, TIterator last, TCompare compare);
82 template <
typename TIterator1,
typename TIterator2>
83 void iter_swap(TIterator1 a, TIterator2 b)
91 template <
typename TIterator1,
typename TIterator2>
92 void iter_swap(TIterator1 a, TIterator2 b)
101 template <
typename T1terator1,
typename TIterator2>
102 TIterator2 swap_ranges(T1terator1 first1,
106 while (first1 != last1)
108 iter_swap(first1++, first2++);
116 template <
typename T1terator1,
typename TIterator2>
117 TIterator2 swap_ranges(T1terator1 first1,
121 return std::swap_ranges(first1, last1, first2);
125 #if ETL_NOT_USING_STL
129 template <
typename TIterator1,
typename TIterator2>
133 copy(TIterator1 sb, TIterator1 se, TIterator2 db)
135 typedef typename etl::iterator_traits<TIterator1>::value_type value_t;
136 typedef typename etl::iterator_traits<TIterator1>::difference_type difference_t;
138 difference_t count = (se - sb);
140 return TIterator2(memmove(db, sb,
sizeof(value_t) * count)) + count;
144 template <
typename TIterator1,
typename TIterator2>
148 copy(TIterator1 sb, TIterator1 se, TIterator2 db)
160 template <
typename TIterator1,
typename TIterator2>
161 TIterator2 copy(TIterator1 sb, TIterator1 se, TIterator2 db)
163 return std::copy(sb, se, db);
167 #if ETL_NOT_USING_STL
170 template <
typename TIterator1,
typename TIterator2>
171 TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db)
183 template <
typename TIterator1,
typename TIterator2>
184 TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db)
186 return std::reverse_copy(sb, se, db);
190 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
194 template <
typename TIterator1,
typename TSize,
typename TIterator2>
198 copy_n(TIterator1 sb, TSize count, TIterator2 db)
200 typedef typename etl::iterator_traits<TIterator1>::value_type value_t;
202 return TIterator2(memmove(db, sb,
sizeof(value_t) * count)) + count;
206 template <
typename TIterator1,
typename TSize,
typename TIterator2>
210 copy_n(TIterator1 sb, TSize count, TIterator2 db)
226 template <
typename TInputIterator,
typename TSize,
typename TOutputIterator>
227 TOutputIterator copy_n(TInputIterator i_begin,
229 TOutputIterator o_begin)
231 return std::copy_n(i_begin, n, o_begin);
235 #if ETL_NOT_USING_STL
239 template <
typename TIterator1,
typename TIterator2>
243 copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
245 typedef typename etl::iterator_traits<TIterator1>::value_type value_t;
247 const size_t length = (se - sb);
249 return TIterator2(memmove(de - length, sb,
sizeof(value_t) * length));
253 template <
typename TIterator1,
typename TIterator2>
257 copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
269 template <
typename TIterator1,
typename TIterator2>
270 TIterator2 copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
272 return std::copy_backward(sb, se, de);
276 #if ETL_CPP11_SUPPORTED
277 #if ETL_NOT_USING_STL
281 template <
typename TIterator1,
typename TIterator2>
285 move(TIterator1 sb, TIterator1 se, TIterator2 db)
289 *db++ = etl::move(*sb++);
296 template <
typename TIterator1,
typename TIterator2>
300 move(TIterator1 sb, TIterator1 se, TIterator2 db)
302 typedef typename etl::iterator_traits<TIterator1>::value_type value_t;
303 typedef typename etl::iterator_traits<TIterator1>::difference_type difference_t;
305 difference_t count = (se - sb);
307 return TIterator2(memmove(db, sb,
sizeof(value_t) * count)) + count;
312 template <
typename TIterator1,
typename TIterator2>
313 TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db)
315 return std::move(sb, se, db);
322 template <
typename TIterator1,
typename TIterator2>
323 TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db)
326 return etl::copy(sb, se, db);
330 #if ETL_CPP11_SUPPORTED
331 #if ETL_NOT_USING_STL
335 template <
typename TIterator1,
typename TIterator2>
339 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
343 *(--de) = etl::move(*(--se));
350 template <
typename TIterator1,
typename TIterator2>
354 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
356 typedef typename etl::iterator_traits<TIterator1>::value_type value_t;
357 typedef typename etl::iterator_traits<TIterator1>::difference_type difference_t;
359 difference_t count = (se - sb);
360 TIterator2 db = de - count;
362 return TIterator2(memmove(db, sb,
sizeof(value_t) * count)) + count;
367 template <
typename TIterator1,
typename TIterator2>
368 TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
370 return std::move_backward(sb, se, de);
376 template <
typename TIterator1,
typename TIterator2>
377 TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
380 return ETL_OR_STD::copy_backward(sb, se, de);
384 #if ETL_NOT_USING_STL
388 template <
typename TIterator>
390 reverse(TIterator b, TIterator e)
396 etl::iter_swap(b, e);
403 template <
typename TIterator>
405 reverse(TIterator b, TIterator e)
407 while ((b != e) && (b != --e))
409 etl::iter_swap(b++, e);
415 template <
typename TIterator>
416 void reverse(TIterator b, TIterator e)
422 #if ETL_NOT_USING_STL
425 template<
typename TIterator,
typename TValue,
typename TCompare>
427 TIterator lower_bound(TIterator first, TIterator last,
const TValue& value, TCompare compare)
429 typedef typename etl::iterator_traits<TIterator>::difference_type difference_t;
431 difference_t count = etl::distance(first, last);
435 TIterator itr = first;
436 difference_t step = count / 2;
438 etl::advance(itr, step);
440 if (compare(*itr, value))
454 template<
typename TIterator,
typename TValue>
456 TIterator lower_bound(TIterator first, TIterator last,
const TValue& value)
460 return etl::lower_bound(first, last, value, compare());
465 template<
typename TIterator,
typename TValue,
typename TCompare>
467 TIterator lower_bound(TIterator first, TIterator last,
const TValue& value, TCompare compare)
469 return std::lower_bound(first, last, value, compare);
472 template<
typename TIterator,
typename TValue>
474 TIterator lower_bound(TIterator first, TIterator last,
const TValue& value)
476 return std::lower_bound(first, last, value);
480 #if ETL_NOT_USING_STL
483 template<
typename TIterator,
typename TValue,
typename TCompare>
485 TIterator upper_bound(TIterator first, TIterator last,
const TValue& value, TCompare compare)
487 typedef typename etl::iterator_traits<TIterator>::difference_type difference_t;
489 difference_t count = etl::distance(first, last);
493 TIterator itr = first;
494 difference_t step = count / 2;
496 etl::advance(itr, step);
498 if (!compare(value, *itr))
512 template<
typename TIterator,
typename TValue>
514 TIterator upper_bound(TIterator first, TIterator last,
const TValue& value)
518 return etl::upper_bound(first, last, value, compare());
523 template<
typename TIterator,
typename TValue,
typename TCompare>
525 TIterator upper_bound(TIterator first, TIterator last,
const TValue& value, TCompare compare)
527 return std::upper_bound(first, last, value, compare);
530 template<
typename TIterator,
typename TValue>
532 TIterator upper_bound(TIterator first, TIterator last,
const TValue& value)
534 return std::upper_bound(first, last, value);
538 #if ETL_NOT_USING_STL
541 template<
typename TIterator,
typename TValue,
typename TCompare>
543 ETL_OR_STD::pair<TIterator, TIterator> equal_range(TIterator first, TIterator last,
const TValue& value, TCompare compare)
545 return ETL_OR_STD::make_pair(etl::lower_bound(first, last, value, compare),
546 etl::upper_bound(first, last, value, compare));
549 template<
typename TIterator,
typename TValue>
551 ETL_OR_STD::pair<TIterator, TIterator> equal_range(TIterator first, TIterator last,
const TValue& value)
555 return ETL_OR_STD::make_pair(etl::lower_bound(first, last, value, compare()),
556 etl::upper_bound(first, last, value, compare()));
561 template<
typename TIterator,
typename TValue,
typename TCompare>
563 std::pair<TIterator, TIterator> equal_range(TIterator first, TIterator last,
const TValue& value, TCompare compare)
565 return std::equal_range(first, last, value, compare);
568 template<
typename TIterator,
typename TValue>
570 std::pair<TIterator, TIterator> equal_range(TIterator first, TIterator last,
const TValue& value)
572 return std::equal_range(first, last, value);
576 #if ETL_NOT_USING_STL
579 template <
typename TIterator,
typename TUnaryPredicate>
581 TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate)
583 while (first != last)
585 if (predicate(*first))
598 template <
typename TIterator,
typename TUnaryPredicate>
600 TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate)
602 return std::find_if(first, last, predicate);
606 #if ETL_NOT_USING_STL
609 template <
typename TIterator,
typename T>
611 TIterator find(TIterator first, TIterator last,
const T& value)
613 while (first != last)
628 template <
typename TIterator,
typename T>
630 TIterator find(TIterator first, TIterator last,
const T& value)
632 return std::find(first, last, value);
636 #if ETL_NOT_USING_STL
639 template<
typename TIterator,
typename TValue>
641 fill(TIterator first, TIterator last,
const TValue& value)
643 while (first != last)
649 template<
typename TIterator,
typename TValue>
651 fill(TIterator first, TIterator last,
const TValue& value)
653 memset(first, value, last - first);
658 template<
typename TIterator,
typename TValue>
659 void fill(TIterator first, TIterator last,
const TValue& value)
661 std::fill(first, last, value);
665 #if ETL_NOT_USING_STL
668 template<
typename TIterator,
typename TSize,
typename TValue>
670 fill_n(TIterator first, TSize count,
const TValue& value)
672 for (TSize i = 0; i < count; ++i)
680 template<
typename TIterator,
typename TSize,
typename TValue>
682 fill_n(TIterator first, TSize count,
const TValue& value)
684 memset(first, value, count);
689 template<
typename TIterator,
typename TSize,
typename TValue>
690 TIterator fill_n(TIterator first, TSize count,
const TValue& value)
692 #if ETL_CPP11_SUPPORTED
693 return std::fill_n(first, count, value);
695 std::fill_n(first, count, value);
696 std::advance(first, count);
702 #if ETL_NOT_USING_STL
705 template <
typename TIterator,
typename T>
707 typename etl::iterator_traits<TIterator>::difference_type count(TIterator first, TIterator last,
const T& value)
709 typename iterator_traits<TIterator>::difference_type n = 0;
711 while (first != last)
726 template <
typename TIterator,
typename T>
728 typename std::iterator_traits<TIterator>::difference_type count(TIterator first, TIterator last,
const T& value)
730 return std::count(first, last, value);
734 #if ETL_NOT_USING_STL
737 template <
typename TIterator,
typename TUnaryPredicate>
739 typename etl::iterator_traits<TIterator>::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate)
741 typename iterator_traits<TIterator>::difference_type n = 0;
743 while (first != last)
745 if (predicate(*first))
758 template <
typename TIterator,
typename TUnaryPredicate>
760 typename std::iterator_traits<TIterator>::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate)
762 return std::count_if(first, last, predicate);
766 #if ETL_NOT_USING_STL
769 template <
typename TIterator1,
typename TIterator2>
772 equal(TIterator1 first1, TIterator1 last1, TIterator2 first2)
774 while (first1 != last1)
776 if (*first1++ != *first2++)
785 template <
typename TIterator1,
typename TIterator2>
788 equal(TIterator1 first1, TIterator1 last1, TIterator2 first2)
790 typedef typename etl::iterator_traits<TIterator1>::value_type value_t;
792 return (memcmp(first1, first2,
sizeof(value_t) * (last1 - first1)) == 0);
795 template <
typename TIterator1,
typename TIterator2>
797 bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
799 return (etl::distance(first1, last1) == etl::distance(first2, last2)) &&
800 etl::equal(first1, last1, first2);
806 template <
typename TIterator1,
typename TIterator2>
808 bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2)
810 return std::equal(first1, last1, first2);
813 #if ETL_CPP14_SUPPORTED
814 template <
typename TIterator1,
typename TIterator2>
816 bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
818 return std::equal(first1, last1, first2, last2);
821 template <
typename TIterator1,
typename TIterator2>
823 bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
825 return (etl::distance(first1, last1) == etl::distance(first2, last2)) &&
826 etl::equal(first1, last1, first2);
831 #if ETL_NOT_USING_STL
834 template <
typename TIterator1,
typename TIterator2,
typename TCompare>
836 bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
837 TIterator2 first2, TIterator2 last2,
840 while ((first1 != last1) && (first2 != last2))
842 if (compare(*first1, *first2))
847 if (compare(*first2, *first1))
856 return (first1 == last1) && (first2 != last2);
861 template <
typename TIterator1,
typename TIterator2>
863 bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
864 TIterator2 first2, TIterator2 last2)
868 return etl::lexicographical_compare(first1, last1, first2, last2, compare());
873 template <
typename TIterator1,
typename TIterator2,
typename TCompare>
875 bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
876 TIterator2 first2, TIterator2 last2,
879 return std::lexicographical_compare(first1, last1, first2, last2, compare);
884 template <
typename TIterator1,
typename TIterator2>
886 bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
887 TIterator2 first2, TIterator2 last2)
889 return std::lexicographical_compare(first1, last1, first2, last2);
893 #if ETL_NOT_USING_STL
896 template <
typename T,
typename TCompare>
898 ETL_CONSTEXPR
const T& min(
const T& a,
const T& b, TCompare compare)
900 return (compare(a, b)) ? a : b;
903 template <
typename T>
905 ETL_CONSTEXPR
const T& min(
const T& a,
const T& b)
909 return etl::min(a, b, compare());
914 template <
typename T,
typename TCompare>
916 ETL_CONSTEXPR
const T& min(
const T& a,
const T& b, TCompare compare)
918 return std::min(a, b, compare);
921 template <
typename T>
923 ETL_CONSTEXPR
const T& min(
const T& a,
const T& b)
925 return std::min(a, b);
929 #if ETL_NOT_USING_STL
932 template <
typename T,
typename TCompare>
934 ETL_CONSTEXPR
const T& max(
const T& a,
const T& b, TCompare compare)
936 return (compare(a, b)) ? b : a;
939 template <
typename T>
941 ETL_CONSTEXPR
const T& max(
const T& a,
const T& b)
945 return etl::max(a, b, compare());
950 template <
typename T,
typename TCompare>
952 ETL_CONSTEXPR
const T& max(
const T& a,
const T& b, TCompare compare)
954 return std::max(a, b, compare);
957 template <
typename T>
959 ETL_CONSTEXPR
const T& max(
const T& a,
const T& b)
961 return std::max(a, b);
965 #if ETL_NOT_USING_STL
968 template <
typename TIteratorIn,
typename TIteratorOut,
typename TUnaryOperation>
969 TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation)
971 while (first1 != last1)
973 *d_first++ = unary_operation(*first1++);
979 template <
typename TIteratorIn1,
typename TIteratorIn2,
typename TIteratorOut,
typename TBinaryOperation>
980 TIteratorOut transform(TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation)
982 while (first1 != last1)
984 *d_first++ = binary_operation(*first1++, *first2++);
992 template <
typename TIteratorIn,
typename TIteratorOut,
typename TUnaryOperation>
993 TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation)
995 return std::transform(first1, last1, d_first, unary_operation);;
998 template <
typename TIteratorIn1,
typename TIteratorIn2,
typename TIteratorOut,
typename TBinaryOperation>
999 TIteratorOut transform(TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation)
1001 return std::transform(first1, last1, first2, d_first, binary_operation);
1005 #if ETL_NOT_USING_STL
1008 template <
typename TIterator,
typename T>
1009 ETL_CONSTEXPR14
void replace(TIterator first, TIterator last,
const T& old_value,
const T& new_value)
1011 while (first != last)
1013 if (*first == old_value)
1024 template <
typename TIterator,
typename TPredicate,
typename T>
1025 ETL_CONSTEXPR14
void replace_if(TIterator first, TIterator last, TPredicate predicate,
const T& new_value)
1027 while (first != last)
1029 if (predicate(*first))
1040 template <
typename TIterator,
typename T>
1041 ETL_CONSTEXPR14
void replace(TIterator first, TIterator last,
const T& old_value,
const T& new_value)
1043 std::replace(first, last, old_value, new_value);
1048 template <
typename TIterator,
typename TPredicate,
typename T>
1049 ETL_CONSTEXPR14
void replace_if(TIterator first, TIterator last, TPredicate predicate,
const T& new_value)
1051 std::replace_if(first, last, predicate, new_value);
1057 namespace private_heap
1060 template <
typename TIterator,
typename TDistance,
typename TValue,
typename TCompare>
1061 void push_heap(TIterator first, TDistance value_index, TDistance top_index, TValue value, TCompare compare)
1063 TDistance parent = (value_index - 1) / 2;
1065 while ((value_index > top_index) && compare(first[parent], value))
1067 first[value_index] = etl::move(first[parent]);
1068 value_index = parent;
1069 parent = (value_index - 1) / 2;
1072 first[value_index] = etl::move(value);
1076 template <
typename TIterator,
typename TDistance,
typename TValue,
typename TCompare>
1077 void adjust_heap(TIterator first, TDistance value_index, TDistance length, TValue value, TCompare compare)
1079 TDistance top_index = value_index;
1080 TDistance child2nd = (2 * value_index) + 2;
1082 while (child2nd < length)
1084 if (compare(first[child2nd], first[child2nd - 1]))
1089 first[value_index] = etl::move(first[child2nd]);
1090 value_index = child2nd;
1091 child2nd = 2 * (child2nd + 1);
1094 if (child2nd == length)
1096 first[value_index] = etl::move(first[child2nd - 1]);
1097 value_index = child2nd - 1;
1100 push_heap(first, value_index, top_index, etl::move(value), compare);
1104 template <
typename TIterator,
typename TDistance,
typename TCompare>
1105 bool is_heap(
const TIterator first,
const TDistance n, TCompare compare)
1107 TDistance parent = 0;
1109 for (TDistance child = 1; child < n; ++child)
1111 if (compare(first[parent], first[child]))
1116 if ((child & 1) == 0)
1126 #if ETL_NOT_USING_STL
1128 template <
typename TIterator,
typename TCompare>
1129 void pop_heap(TIterator first, TIterator last, TCompare compare)
1131 typedef typename etl::iterator_traits<TIterator>::value_type value_t;
1132 typedef typename etl::iterator_traits<TIterator>::difference_type distance_t;
1134 value_t value = etl::move(last[-1]);
1135 last[-1] = etl::move(first[0]);
1137 private_heap::adjust_heap(first, distance_t(0), distance_t(last - first - 1), etl::move(value), compare);
1141 template <
typename TIterator>
1142 void pop_heap(TIterator first, TIterator last)
1146 etl::pop_heap(first, last, compare());
1150 template <
typename TIterator,
typename TCompare>
1151 void push_heap(TIterator first, TIterator last, TCompare compare)
1153 typedef typename etl::iterator_traits<TIterator>::difference_type difference_t;
1154 typedef typename etl::iterator_traits<TIterator>::value_type value_t;
1156 private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(etl::move(*(last - 1))), compare);
1160 template <
typename TIterator>
1161 void push_heap(TIterator first, TIterator last)
1165 etl::push_heap(first, last, compare());
1169 template <
typename TIterator,
typename TCompare>
1170 void make_heap(TIterator first, TIterator last, TCompare compare)
1172 typedef typename etl::iterator_traits<TIterator>::difference_type difference_t;
1174 if ((last - first) < 2)
1179 difference_t length = last - first;
1180 difference_t parent = (length - 2) / 2;
1184 private_heap::adjust_heap(first, parent, length, etl::move(*(first + parent)), compare);
1196 template <
typename TIterator>
1197 void make_heap(TIterator first, TIterator last)
1201 etl::make_heap(first, last, compare());
1205 template <
typename TIterator>
1207 bool is_heap(TIterator first, TIterator last)
1211 return private_heap::is_heap(first, last - first, compare());
1215 template <
typename TIterator,
typename TCompare>
1217 bool is_heap(TIterator first, TIterator last, TCompare compare)
1219 return private_heap::is_heap(first, last - first, compare);
1223 template <
typename TIterator>
1224 void sort_heap(TIterator first, TIterator last)
1226 while (first != last)
1228 etl::pop_heap(first, last--);
1233 template <
typename TIterator,
typename TCompare>
1234 void sort_heap(TIterator first, TIterator last, TCompare compare)
1236 while (first != last)
1238 etl::pop_heap(first, last--, compare);
1246 template <
typename TIterator,
typename TCompare>
1247 void pop_heap(TIterator first, TIterator last, TCompare compare)
1249 std::pop_heap(first, last, compare);
1253 template <
typename TIterator>
1254 void pop_heap(TIterator first, TIterator last)
1256 std::pop_heap(first, last);
1260 template <
typename TIterator,
typename TCompare>
1261 void push_heap(TIterator first, TIterator last, TCompare compare)
1263 std::push_heap(first, last, compare);
1267 template <
typename TIterator>
1268 void push_heap(TIterator first, TIterator last)
1270 std::push_heap(first, last);
1274 template <
typename TIterator,
typename TCompare>
1275 void make_heap(TIterator first, TIterator last, TCompare compare)
1277 std::make_heap(first, last, compare);
1281 template <
typename TIterator>
1282 void make_heap(TIterator first, TIterator last)
1284 std::make_heap(first, last);
1288 template <
typename TIterator,
typename TCompare>
1290 bool is_heap(TIterator first, TIterator last, TCompare compare)
1292 #if ETL_CPP11_SUPPORTED
1293 return std::is_heap(first, last, compare);
1295 return private_heap::is_heap(first, last - first, compare());
1300 template <
typename TIterator>
1302 bool is_heap(TIterator first, TIterator last)
1304 #if ETL_CPP11_SUPPORTED
1305 return std::is_heap(first, last);
1308 return private_heap::is_heap(first, last - first, compare());
1313 template <
typename TIterator,
typename TCompare>
1314 void sort_heap(TIterator first, TIterator last, TCompare compare)
1316 std::sort_heap(first, last, compare);
1320 template <
typename TIterator>
1321 void sort_heap(TIterator first, TIterator last)
1323 std::sort_heap(first, last);
1328 #if ETL_NOT_USING_STL
1331 template<
typename TIterator1,
typename TIterator2,
typename TCompare>
1333 TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare)
1337 TIterator1 itr = first;
1338 TIterator2 search_itr = search_first;
1342 if (search_itr == search_last)
1352 if (!compare(*itr, *search_itr))
1366 template<
typename TIterator1,
typename TIterator2>
1368 TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last)
1372 return etl::search(first, last, search_first, search_last, compare());
1377 template<
typename TIterator1,
typename TIterator2,
typename TCompare>
1379 TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare)
1381 return std::search(first, last, search_first, search_last, compare);
1385 template<
typename TIterator1,
typename TIterator2>
1387 TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last)
1389 return std::search(first, last, search_first, search_last);
1393 #if ETL_NOT_USING_STL
1396 namespace private_algorithm
1399 template <
typename TIterator>
1400 TIterator rotate_general(TIterator first, TIterator middle, TIterator last)
1402 TIterator next = middle;
1404 while (first != next)
1408 swap(*first++, *next++);
1414 else if (first == middle)
1424 template <
typename TIterator>
1425 TIterator rotate_left_by_one(TIterator first, TIterator last)
1427 typedef typename etl::iterator_traits<TIterator>::value_type value_type;
1430 value_type temp(etl::move(*first));
1433 TIterator result = etl::move(etl::next(first), last, first);
1436 *result = etl::move(temp);
1443 template <
typename TIterator>
1444 TIterator rotate_right_by_one(TIterator first, TIterator last)
1446 typedef typename etl::iterator_traits<TIterator>::value_type value_type;
1449 TIterator previous = etl::prev(last);
1450 value_type temp(etl::move(*previous));
1453 TIterator result = etl::move_backward(first, previous, last);
1456 *first = etl::move(temp);
1464 template<
typename TIterator>
1465 TIterator rotate(TIterator first, TIterator middle, TIterator last)
1467 if (etl::next(first) == middle)
1469 return private_algorithm::rotate_left_by_one(first, last);
1472 if (etl::next(middle) == last)
1474 return private_algorithm::rotate_right_by_one(first, last);
1477 return private_algorithm::rotate_general(first, middle, last);
1482 template<
typename TIterator>
1483 TIterator rotate(TIterator first, TIterator middle, TIterator last)
1485 return std::rotate(first, middle, last);
1489 #if ETL_NOT_USING_STL
1493 template <
typename TIterator1,
typename TIterator2,
typename TPredicate>
1495 TIterator1 find_end(TIterator1 b, TIterator1 e,
1496 TIterator2 sb, TIterator2 se,
1497 TPredicate predicate)
1504 TIterator1 result = e;
1508 TIterator1 new_result = etl::search(b, e, sb, se, predicate);
1510 if (new_result == e)
1516 result = new_result;
1525 template <
typename TIterator1,
typename TIterator2>
1527 TIterator1 find_end(TIterator1 b, TIterator1 e,
1528 TIterator2 sb, TIterator2 se)
1532 return find_end(b, e, sb, se, predicate());
1538 template <
typename TIterator1,
typename TIterator2,
typename TPredicate>
1540 TIterator1 find_end(TIterator1 b, TIterator1 e,
1541 TIterator2 sb, TIterator2 se,
1542 TPredicate predicate)
1544 return std::find_end(b, e, sb, se, predicate);
1548 template <
typename TIterator1,
typename TIterator2>
1550 TIterator1 find_end(TIterator1 b, TIterator1 e,
1551 TIterator2 sb, TIterator2 se)
1553 return std::find_end(b, e, sb, se);
1557 #if ETL_NOT_USING_STL
1563 template <
typename TIterator,
typename TCompare>
1569 TIterator minimum =
begin;
1573 if (compare(*
begin, *minimum))
1589 template <
typename TIterator>
1594 typedef typename etl::iterator_traits<TIterator>::value_type value_t;
1604 template <
typename TIterator,
typename TCompare>
1618 template <
typename TIterator>
1627 #if ETL_NOT_USING_STL
1633 template <
typename TIterator,
typename TCompare>
1639 TIterator maximum =
begin;
1643 if (!compare(*
begin, *maximum))
1659 template <
typename TIterator>
1664 typedef typename etl::iterator_traits<TIterator>::value_type value_t;
1674 template <
typename TIterator,
typename TCompare>
1688 template <
typename TIterator>
1697 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
1703 template <
typename TIterator,
typename TCompare>
1709 TIterator minimum =
begin;
1710 TIterator maximum =
begin;
1727 return ETL_OR_STD::pair<TIterator, TIterator>(minimum, maximum);
1735 template <
typename TIterator>
1740 typedef typename etl::iterator_traits<TIterator>::value_type value_t;
1750 template <
typename TIterator,
typename TCompare>
1764 template <
typename TIterator>
1773 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
1779 template <
typename T>
1781 ETL_OR_STD::pair<const T&, const T&>
minmax(
const T& a,
1784 return (b < a) ? ETL_OR_STD::pair<const T&, const T&>(b, a) : ETL_OR_STD::pair<const T&, const T&>(a, b);
1792 template <
typename T,
typename TCompare>
1794 ETL_OR_STD::pair<const T&, const T&>
minmax(
const T& a,
1798 return compare(b, a) ? ETL_OR_STD::pair<const T&, const T&>(b, a) : ETL_OR_STD::pair<const T&, const T&>(a, b);
1806 template <
typename T>
1808 std::pair<const T&, const T&>
minmax(
const T& a,
1819 template <
typename T,
typename TCompare>
1821 std::pair<const T&, const T&>
minmax(
const T& a,
1829 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
1835 template <
typename TIterator>
1842 TIterator next =
begin;
1844 while (++next !=
end)
1863 template <
typename TIterator,
typename TCompare>
1871 TIterator next =
begin;
1873 while (++next !=
end)
1892 template <
typename TIterator>
1905 template <
typename TIterator,
typename TCompare>
1915 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
1921 template<
typename TIterator>
1934 template<
typename TIterator,
typename TCompare>
1948 template<
typename TIterator>
1961 template<
typename TIterator,
typename TCompare>
1971 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
1977 template <
typename TIterator,
typename TUnaryPredicate>
1981 TUnaryPredicate predicate)
1985 if (!predicate(*
begin))
2001 template <
typename TIterator,
typename TUnaryPredicate>
2005 TUnaryPredicate predicate)
2011 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2017 template <
typename TIterator1,
typename TIterator2>
2025 TIterator2 end2 = begin2;
2027 etl::advance(end2, etl::distance(begin1, end1));
2029 for (TIterator1 i = begin1; i != end1; ++i)
2031 if (i == etl::find(begin1, i, *i))
2033 size_t n = etl::count(begin2, end2, *i);
2035 if (n == 0 ||
size_t(etl::count(i, end1, *i)) != n)
2051 template <
typename TIterator1,
typename TIterator2,
typename TBinaryPredicate>
2056 TBinaryPredicate predicate)
2060 TIterator2 end2 = begin2;
2062 etl::advance(end2, etl::distance(begin1, end1));
2064 for (TIterator1 i = begin1; i != end1; ++i)
2066 if (i == etl::find_if(begin1, i, etl::bind1st(predicate, *i)))
2068 size_t n = etl::count(begin2, end2, *i);
2070 if (n == 0 ||
size_t(etl::count(i, end1, *i)) != n)
2086 template <
typename TIterator1,
typename TIterator2>
2095 for (TIterator1 i = begin1; i != end1; ++i)
2097 if (i == etl::find(begin1, i, *i))
2099 size_t n = etl::count(begin2, end2, *i);
2101 if (n == 0 ||
size_t(etl::count(i, end1, *i)) != n)
2117 template <
typename TIterator1,
typename TIterator2,
typename TBinaryPredicate>
2123 TBinaryPredicate predicate)
2127 for (TIterator1 i = begin1; i != end1; ++i)
2129 if (i == etl::find_if(begin1, i, etl::bind1st(predicate, *i)))
2131 size_t n = etl::count(begin2, end2, *i);
2133 if (n == 0 ||
size_t(etl::count(i, end1, *i)) != n)
2149 template <
typename TIterator1,
typename TIterator2>
2163 template <
typename TIterator1,
typename TIterator2,
typename TBinaryPredicate>
2168 TBinaryPredicate predicate)
2173 #if ETL_CPP14_SUPPORTED
2179 template <
typename TIterator1,
typename TIterator2>
2194 template <
typename TIterator1,
typename TIterator2,
typename TBinaryPredicate>
2200 TBinaryPredicate predicate)
2207 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2213 template <
typename TIterator,
typename TUnaryPredicate>
2217 TUnaryPredicate predicate)
2221 if (!predicate(*
begin++))
2229 if (predicate(*
begin++))
2243 template <
typename TIterator,
typename TUnaryPredicate>
2247 TUnaryPredicate predicate)
2253 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2259 template <
typename TIterator,
typename TUnaryPredicate>
2263 TUnaryPredicate predicate)
2267 if (!predicate(*
begin))
2283 template <
typename TIterator,
typename TUnaryPredicate>
2287 TUnaryPredicate predicate)
2293 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2300 template <
typename TSource,
typename TDestinationTrue,
typename TDestinationFalse,
typename TUnaryPredicate>
2303 TDestinationTrue destination_true,
2304 TDestinationFalse destination_false,
2305 TUnaryPredicate predicate)
2309 if (predicate(*
begin))
2311 *destination_true++ = *
begin++;
2315 *destination_false++ = *
begin++;
2319 return ETL_OR_STD::pair<TDestinationTrue, TDestinationFalse>(destination_true, destination_false);
2328 template <
typename TSource,
typename TDestinationTrue,
typename TDestinationFalse,
typename TUnaryPredicate>
2331 TDestinationTrue destination_true,
2332 TDestinationFalse destination_false,
2333 TUnaryPredicate predicate)
2339 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2345 template <
typename TIterator,
typename TOutputIterator,
typename TUnaryPredicate>
2348 TOutputIterator out,
2349 TUnaryPredicate predicate)
2353 if (predicate(*
begin))
2369 template <
typename TIterator,
typename TOutputIterator,
typename TUnaryPredicate>
2372 TOutputIterator out,
2373 TUnaryPredicate predicate)
2379 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2385 template <
typename TIterator,
typename TUnaryPredicate>
2389 TUnaryPredicate predicate)
2399 template <
typename TIterator,
typename TUnaryPredicate>
2403 TUnaryPredicate predicate)
2409 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2415 template <
typename TIterator,
typename TUnaryPredicate>
2419 TUnaryPredicate predicate)
2421 return etl::find_if(
begin,
end, predicate) !=
end;
2429 template <
typename TIterator,
typename TUnaryPredicate>
2433 TUnaryPredicate predicate)
2439 #if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
2445 template <
typename TIterator,
typename TUnaryPredicate>
2449 TUnaryPredicate predicate)
2451 return etl::find_if(
begin,
end, predicate) ==
end;
2459 template <
typename TIterator,
typename TUnaryPredicate>
2463 TUnaryPredicate predicate)
2469 #if ETL_NOT_USING_STL
2475 template <
typename TIterator,
typename TCompare>
2476 void sort(TIterator first, TIterator last, TCompare compare)
2485 template <
typename TIterator>
2486 void sort(TIterator first, TIterator last)
2497 template <
typename TIterator,
typename TCompare>
2498 void stable_sort(TIterator first, TIterator last, TCompare compare)
2508 template <
typename TIterator>
2519 template <
typename TIterator,
typename TCompare>
2529 template <
typename TIterator>
2530 void sort(TIterator first, TIterator last)
2541 template <
typename TIterator,
typename TCompare>
2552 template <
typename TIterator>
2576 template <
typename TInputIterator,
2577 typename TOutputIterator>
2581 TInputIterator i_end,
2582 TOutputIterator o_begin,
2583 TOutputIterator o_end)
2585 size_t s_size = etl::distance(i_begin, i_end);
2586 size_t d_size = etl::distance(o_begin, o_end);
2587 size_t size = (s_size < d_size) ? s_size : d_size;
2589 return etl::copy(i_begin, i_begin + size, o_begin);
2603 template <
typename TInputIterator,
2604 typename TOutputIterator>
2608 TInputIterator i_end,
2609 TOutputIterator o_begin,
2610 TOutputIterator o_end)
2612 while ((i_begin != i_end) && (o_begin != o_end))
2614 *o_begin++ = *i_begin++;
2625 template <
typename TInputIterator,
2627 typename TOutputIterator>
2630 TOutputIterator o_begin,
2631 TOutputIterator o_end)
2633 while ((n-- > 0) && (o_begin != o_end))
2635 *o_begin++ = *i_begin++;
2646 template <
typename TInputIterator,
2648 typename TOutputIterator,
2652 TOutputIterator o_begin,
2655 while ((n1-- > 0) && (n2-- > 0))
2657 *o_begin++ = *i_begin++;
2669 template <
typename TInputIterator,
2670 typename TOutputIterator,
2671 typename TUnaryPredicate>
2673 TInputIterator i_end,
2674 TOutputIterator o_begin,
2675 TOutputIterator o_end,
2676 TUnaryPredicate predicate)
2678 while ((i_begin != i_end) && (o_begin != o_end))
2680 if (predicate(*i_begin))
2682 *o_begin++ = *i_begin;
2696 template <
typename TInputIterator,
2698 typename TOutputIterator,
2699 typename TUnaryPredicate>
2702 TOutputIterator o_begin,
2703 TUnaryPredicate predicate)
2707 if (predicate(*i_begin))
2709 *o_begin++ = *i_begin;
2718 #if ETL_CPP11_SUPPORTED
2730 template <
typename TInputIterator,
2731 typename TOutputIterator>
2734 move_s(TInputIterator i_begin,
2735 TInputIterator i_end,
2736 TOutputIterator o_begin,
2737 TOutputIterator o_end)
2739 size_t s_size = etl::distance(i_begin, i_end);
2740 size_t d_size = etl::distance(o_begin, o_end);
2741 size_t size = (s_size < d_size) ? s_size : d_size;
2743 return etl::move(i_begin, i_begin + size, o_begin);
2757 template <
typename TInputIterator,
2758 typename TOutputIterator>
2761 move_s(TInputIterator i_begin,
2762 TInputIterator i_end,
2763 TOutputIterator o_begin,
2764 TOutputIterator o_end)
2766 while ((i_begin != i_end) && (o_begin != o_end))
2768 *o_begin++ = etl::move(*i_begin++);
2786 template <
typename TInputIterator,
typename TOutputIterator>
2787 TOutputIterator
move_s(TInputIterator i_begin,
2788 TInputIterator i_end,
2789 TOutputIterator o_begin,
2790 TOutputIterator o_end)
2793 return etl::copy_s(i_begin, i_end, o_begin, o_end);
2802 template <
typename TIterator,
typename TValue>
2806 const TValue& value)
2808 TIterator it = etl::lower_bound(
begin,
end, value);
2810 if ((it ==
end) || (*it != value))
2823 template <
typename TIterator,
2825 typename TBinaryPredicate,
2826 typename TBinaryEquality>
2830 const TValue& value,
2831 TBinaryPredicate predicate,
2832 TBinaryEquality equality)
2834 TIterator it = etl::lower_bound(
begin,
end, value, predicate);
2836 if ((it ==
end) || !equality(*it, value))
2848 template <
typename TIterator,
2849 typename TUnaryFunction,
2850 typename TUnaryPredicate>
2852 const TIterator
end,
2853 TUnaryFunction
function,
2854 TUnaryPredicate predicate)
2858 if (predicate(*
begin))
2873 template <
typename TIterator,
2875 typename TUnaryFunction>
2878 TUnaryFunction
function)
2892 template <
typename TIterator,
2894 typename TUnaryFunction,
2895 typename TUnaryPredicate>
2898 TUnaryFunction
function,
2899 TUnaryPredicate predicate)
2903 if (predicate(*
begin))
2920 template <
typename TInputIterator,
typename TOutputIterator,
typename TUnaryFunction>
2922 TInputIterator i_end,
2923 TOutputIterator o_begin,
2924 TOutputIterator o_end,
2925 TUnaryFunction
function)
2927 while ((i_begin != i_end) && (o_begin != o_end))
2929 *o_begin++ =
function(*i_begin++);
2941 template <
typename TInputIterator,
2943 typename TOutputIterator,
2944 typename TUnaryFunction>
2947 TOutputIterator o_begin,
2948 TUnaryFunction
function)
2950 TInputIterator i_end(i_begin);
2951 etl::advance(i_end, n);
2953 etl::transform(i_begin, i_end, o_begin,
function);
2962 template <
typename TInputIterator1,
2963 typename TInputIterator2,
2965 typename TOutputIterator,
2966 typename TBinaryFunction>
2968 TInputIterator2 i_begin2,
2970 TOutputIterator o_begin,
2971 TBinaryFunction
function)
2973 TInputIterator1 i_end1(i_begin1);
2974 etl::advance(i_end1, n);
2976 etl::transform(i_begin1, i_end1, i_begin2, o_begin,
function);
2983 template <
typename TInputIterator,
2984 typename TOutputIterator,
2985 typename TUnaryFunction,
2986 typename TUnaryPredicate>
2988 const TInputIterator i_end,
2989 TOutputIterator o_begin,
2990 TUnaryFunction
function,
2991 TUnaryPredicate predicate)
2993 while (i_begin != i_end)
2995 if (predicate(*i_begin))
2997 *o_begin++ =
function(*i_begin);
3010 template <
typename TInputIterator1,
3011 typename TInputIterator2,
3012 typename TOutputIterator,
3013 typename TBinaryFunction,
3014 typename TBinaryPredicate>
3016 const TInputIterator1 i_end1,
3017 TInputIterator2 i_begin2,
3018 TOutputIterator o_begin,
3019 TBinaryFunction
function,
3020 TBinaryPredicate predicate)
3022 while (i_begin1 != i_end1)
3024 if (predicate(*i_begin1, *i_begin2))
3026 *o_begin++ =
function(*i_begin1, *i_begin2);
3040 template <
typename TInputIterator,
3042 typename TOutputIterator,
3043 typename TUnaryFunction,
3044 typename TUnaryPredicate>
3047 TOutputIterator o_begin,
3048 TUnaryFunction
function,
3049 TUnaryPredicate predicate)
3053 if (predicate(*i_begin))
3055 *o_begin++ =
function(*i_begin);
3068 template <
typename TInputIterator1,
3069 typename TInputIterator2,
3071 typename TOutputIterator,
3072 typename TBinaryFunction,
3073 typename TBinaryPredicate>
3075 TInputIterator2 i_begin2,
3077 TOutputIterator o_begin,
3078 TBinaryFunction
function,
3079 TBinaryPredicate predicate)
3083 if (predicate(*i_begin1, *i_begin2))
3085 *o_begin++ =
function(*i_begin1, *i_begin2);
3100 template <
typename TSource,
typename TDestinationTrue,
typename TDestinationFalse,
3101 typename TUnaryFunctionTrue,
typename TUnaryFunctionFalse,
3102 typename TUnaryPredicate>
3105 TDestinationTrue destination_true,
3106 TDestinationFalse destination_false,
3107 TUnaryFunctionTrue function_true,
3108 TUnaryFunctionFalse function_false,
3109 TUnaryPredicate predicate)
3113 if (predicate(*
begin))
3115 *destination_true++ = function_true(*
begin++);
3119 *destination_false++ = function_false(*
begin++);
3123 return ETL_OR_STD::pair<TDestinationTrue, TDestinationFalse>(destination_true, destination_false);
3131 template <
typename TSource1,
3133 typename TDestinationTrue,
3134 typename TDestinationFalse,
3135 typename TBinaryFunctionTrue,
3136 typename TBinaryFunctionFalse,
3137 typename TBinaryPredicate>
3141 TDestinationTrue destination_true,
3142 TDestinationFalse destination_false,
3143 TBinaryFunctionTrue function_true,
3144 TBinaryFunctionFalse function_false,
3145 TBinaryPredicate predicate)
3147 while (begin1 != end1)
3149 if (predicate(*begin1, *begin2))
3151 *destination_true++ = function_true(*begin1++, *begin2++);
3155 *destination_false++ = function_false(*begin1++, *begin2++);
3159 return ETL_OR_STD::pair<TDestinationTrue, TDestinationFalse>(destination_true, destination_false);
3167 template <
typename TIterator,
typename TCompare>
3175 typedef typename etl::iterator_traits<TIterator>::difference_type difference_t;
3177 difference_t n = etl::distance(first, last);
3179 for (difference_t i = n / 2; i > 0; i /= 2)
3181 for (difference_t j = i; j < n; ++j)
3183 for (difference_t k = j - i; k >= 0; k -= i)
3185 TIterator itr1 = first;
3186 TIterator itr2 = first;
3188 etl::advance(itr1, k);
3189 etl::advance(itr2, k + i);
3193 etl::iter_swap(itr1, itr2);
3204 template <
typename TIterator>
3215 template <
typename TIterator,
typename TCompare>
3218 for (TIterator itr = first; itr != last; ++itr)
3220 etl::rotate(etl::upper_bound(first, itr, *itr,
compare), itr, etl::next(itr));
3228 template <
typename TIterator>
3239 template <
typename TIterator,
typename TCompare >
3242 if (!etl::is_heap(first, last,
compare))
3244 etl::make_heap(first, last,
compare);
3247 etl::sort_heap(first, last,
compare);
3254 template <
typename TIterator>
3257 if (!etl::is_heap(first, last))
3259 etl::make_heap(first, last);
3262 etl::sort_heap(first, last);
3268 #if ETL_CPP11_SUPPORTED
3269 template <
typename T>
3271 constexpr
const T& multimax(
const T& a,
const T& b)
3273 return a < b ? b : a;
3276 template <
typename T,
typename... Tx>
3278 constexpr
const T& multimax(
const T& t,
const Tx&... tx)
3280 return multimax(t, multimax(tx...));
3288 #if ETL_CPP11_SUPPORTED
3289 template <
typename TCompare,
typename T>
3291 constexpr
const T& multimax_compare(TCompare compare,
const T& a,
const T& b)
3293 return compare(a, b) ? b : a;
3296 template <
typename TCompare,
typename T,
typename... Tx>
3298 constexpr
const T& multimax_compare(TCompare compare,
const T& t,
const Tx&... tx)
3300 return multimax_compare(compare, t, multimax_compare(compare, tx...));
3307 #if ETL_CPP11_SUPPORTED
3308 template <
typename T>
3310 constexpr
const T& multimin(
const T& a,
const T& b)
3312 return a < b ? a : b;
3315 template <
typename T,
typename... Tx>
3317 constexpr
const T& multimin(
const T& t,
const Tx&... tx)
3319 return multimin(t, multimin(tx...));
3327 #if ETL_CPP11_SUPPORTED
3328 template <
typename TCompare,
typename T>
3330 constexpr
const T& multimin_compare(TCompare compare,
const T& a,
const T& b)
3332 return compare(a, b) ? a : b;
3335 template <
typename TCompare,
typename T,
typename... Tx>
3337 constexpr
const T& multimin_compare(TCompare compare,
const T& t,
const Tx&... tx)
3339 return multimin_compare(compare, t, multimin_compare(compare, tx...));
3346 #if ETL_CPP11_SUPPORTED
3347 template <
typename TIterator>
3349 constexpr
const TIterator& multimax_iter(
const TIterator& a,
const TIterator& b)
3351 return *a < *b ? b : a;
3354 template <
typename TIterator,
typename... TIteratorx>
3356 constexpr
const TIterator& multimax_iter(
const TIterator& t,
const TIteratorx&... tx)
3358 return multimax_iter(t, multimax_iter(tx...));
3366 #if ETL_CPP11_SUPPORTED
3367 template <
typename TCompare,
typename TIterator>
3369 constexpr
const TIterator& multimax_iter_compare(TCompare compare,
const TIterator& a,
const TIterator& b)
3371 return compare(*a, *b) ? b : a;
3374 template <
typename TCompare,
typename TIterator,
typename... TIteratorx>
3376 constexpr
const TIterator& multimax_iter_compare(TCompare compare,
const TIterator& t,
const TIteratorx&... tx)
3378 return multimax_iter_compare(compare, t, multimax_iter_compare(compare, tx...));
3385 #if ETL_CPP11_SUPPORTED
3386 template <
typename TIterator>
3388 constexpr
const TIterator& multimin_iter(
const TIterator& a,
const TIterator& b)
3390 return *a < *b ? a : b;
3393 template <
typename TIterator,
typename... Tx>
3395 constexpr
const TIterator& multimin_iter(
const TIterator& t,
const Tx&... tx)
3397 return multimin_iter(t, multimin_iter(tx...));
3405 #if ETL_CPP11_SUPPORTED
3406 template <
typename TCompare,
typename TIterator>
3408 constexpr
const TIterator& multimin_iter_compare(TCompare compare,
const TIterator& a,
const TIterator& b)
3410 return compare(*a, *b) ? a : b;
3413 template <
typename TCompare,
typename TIterator,
typename... Tx>
3415 constexpr
const TIterator& multimin_iter_compare(TCompare compare,
const TIterator& t,
const Tx&... tx)
3417 return multimin_iter_compare(compare, t, multimin_iter_compare(compare, tx...));
TOutputIterator copy_n_if(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryPredicate predicate)
Definition: algorithm.h:2700
ETL_NODISCARD bool any_of(TIterator begin, TIterator end, TUnaryPredicate predicate)
Definition: algorithm.h:2417
ETL_NODISCARD TIterator partition_point(TIterator begin, TIterator end, TUnaryPredicate predicate)
Definition: algorithm.h:2261
TOutputIterator transform_if(TInputIterator i_begin, const TInputIterator i_end, TOutputIterator o_begin, TUnaryFunction function, TUnaryPredicate predicate)
Definition: algorithm.h:2987
TUnaryFunction for_each_if(TIterator begin, const TIterator end, TUnaryFunction function, TUnaryPredicate predicate)
Definition: algorithm.h:2851
ETL_NODISCARD bool is_partitioned(TIterator begin, TIterator end, TUnaryPredicate predicate)
Definition: algorithm.h:2215
ETL_NODISCARD TIterator min_element(TIterator begin, TIterator end, TCompare compare)
Definition: algorithm.h:1606
void sort(TIterator first, TIterator last)
Definition: algorithm.h:2530
TOutputIterator transform_n_if(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryFunction function, TUnaryPredicate predicate)
Definition: algorithm.h:3045
TOutputIterator copy_n_s(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TOutputIterator o_end)
Definition: algorithm.h:2628
ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end, TCompare compare)
Definition: algorithm.h:1936
ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end)
Definition: algorithm.h:1837
ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2)
Definition: algorithm.h:2019
ETL_NODISCARD ETL_OR_STD::pair< TIterator, TIterator > minmax_element(TIterator begin, TIterator end)
Definition: algorithm.h:1737
ETL_NODISCARD TIterator binary_find(TIterator begin, TIterator end, const TValue &value)
Definition: algorithm.h:2804
ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end, TCompare compare)
Definition: algorithm.h:1865
TOutputIterator copy_if(TIterator begin, TIterator end, TOutputIterator out, TUnaryPredicate predicate)
Definition: algorithm.h:2346
void shell_sort(TIterator first, TIterator last)
Definition: algorithm.h:3205
ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end)
Definition: algorithm.h:1923
void sort(TIterator first, TIterator last, TCompare compare)
Definition: algorithm.h:2520
ETL_NODISCARD TIterator max_element(TIterator begin, TIterator end)
Definition: algorithm.h:1690
TOutputIterator transform_s(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end, TUnaryFunction function)
Definition: algorithm.h:2921
TIterator for_each_n_if(TIterator begin, TSize n, TUnaryFunction function, TUnaryPredicate predicate)
Definition: algorithm.h:2896
ETL_OR_STD::pair< TDestinationTrue, TDestinationFalse > partition_transform(TSource begin, TSource end, TDestinationTrue destination_true, TDestinationFalse destination_false, TUnaryFunctionTrue function_true, TUnaryFunctionFalse function_false, TUnaryPredicate predicate)
Definition: algorithm.h:3103
TOutputIterator copy_if_s(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end, TUnaryPredicate predicate)
Definition: algorithm.h:2672
ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, TIterator2 end2, TBinaryPredicate predicate)
Definition: algorithm.h:2119
ETL_NODISCARD bool none_of(TIterator begin, TIterator end, TUnaryPredicate predicate)
Definition: algorithm.h:2447
TIterator for_each_n(TIterator begin, TSize n, TUnaryFunction function)
Definition: algorithm.h:2876
ETL_NODISCARD ETL_OR_STD::pair< const T &, const T & > minmax(const T &a, const T &b)
Definition: algorithm.h:1781
etl::enable_if< etl::is_random_iterator< TInputIterator >::value &&etl::is_random_iterator< TOutputIterator >::value, TOutputIterator >::type copy_s(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end)
Definition: algorithm.h:2580
void insertion_sort(TIterator first, TIterator last)
Definition: algorithm.h:3229
ETL_OR_STD::pair< TDestinationTrue, TDestinationFalse > partition_copy(TSource begin, TSource end, TDestinationTrue destination_true, TDestinationFalse destination_false, TUnaryPredicate predicate)
Definition: algorithm.h:2301
ETL_NODISCARD bool all_of(TIterator begin, TIterator end, TUnaryPredicate predicate)
Definition: algorithm.h:2387
ETL_NODISCARD TIterator find_if_not(TIterator begin, TIterator end, TUnaryPredicate predicate)
Definition: algorithm.h:1979
ETL_NODISCARD TIterator min_element(TIterator begin, TIterator end)
Definition: algorithm.h:1620
void transform_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryFunction function)
Definition: algorithm.h:2945
TOutputIterator move_s(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end)
Definition: algorithm.h:2787
ETL_NODISCARD ETL_OR_STD::pair< const T &, const T & > minmax(const T &a, const T &b, TCompare compare)
Definition: algorithm.h:1794
ETL_NODISCARD ETL_OR_STD::pair< TIterator, TIterator > minmax_element(TIterator begin, TIterator end, TCompare compare)
Definition: algorithm.h:1705
void stable_sort(TIterator first, TIterator last, TCompare compare)
Definition: algorithm.h:2542
ETL_NODISCARD TIterator max_element(TIterator begin, TIterator end, TCompare compare)
Definition: algorithm.h:1676
void heap_sort(TIterator first, TIterator last, TCompare compare)
Definition: algorithm.h:3240
void stable_sort(TIterator first, TIterator last)
Definition: algorithm.h:2553
ETL_CONSTEXPR TContainer::iterator begin(TContainer &container)
Definition: container.h:49
ETL_CONSTEXPR TContainer::iterator end(TContainer &container)
Definition: container.h:99
enable_if
Definition: type_traits_generator.h:1228
is_pointer
Definition: type_traits_generator.h:1041
is_same
Definition: type_traits_generator.h:981
is_trivially_copyable
Definition: type_traits_generator.h:1191
Definition: absolute.h:37
void swap(etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
Template deduction guides.
Definition: array.h:570
Definition: functional.h:136
Definition: iterator.h:633
Definition: functional.h:112