Algorithms

Utilities

Algorithms

A set of algorithms from the STL.

If ETL_NO_STL is defined then the ETL implements its own reverse engineered versions.
Otherwise, the ETL will often be a wrapper around the STL’s implementation.

Functions returning pair will either use std::pair or, if ETL_NO_STL is defined, etl::pair.

Note:
Some algorithms will be constexpr, dependent on the compiler support and ETL setup.

swap

Only defined if ETL_NO_STL is defined.

template <typename T>
void swap(T& a, T& b) ETL_NOEXCEPT

Description
Swaps two values.

template <typename T, size_t N>
void swap(T(&a)[N], T(&b)[N]) ETL_NOEXCEPT

Description
Swaps two arrays.

iter_swap

template <typename TIterator1, typename TIterator2>
void iter_swap(TIterator1 a, TIterator2 b)

Description
Swaps the elements pointed to by two iterators.

swap_ranges

template <typename T1terator1, typename TIterator2>
TIterator2 swap_ranges(T1terator1 first1,
                       T1terator1 last1,
                       TIterator2 first2)

Description
Swaps two ranges of elements.

copy

template <typename TInputIterator, typename TOutputIterator>
TOutputIterator copy(TInputIterator sb, TInputIterator se, TOutputIterator db)

Description
Copies the elements in the range, defined by sb, se, to another range beginning at db.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

copy_s

ETL extension

template <typename TInputIterator, typename TOutputIterator>
TOutputIterator copy_s(TInputIterator  i_begin, TInputIterator  i_end,
                       TOutputIterator o_begin, TOutputIterator o_end)

Description
A safer four parameter version that will stop copying when either iterator reaches the end of its range.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

copy_n

template <typename TInputIterator, typename TSize, typename TOutputIterator>
TOutputIterator copy_n(TInputIterator begin, TSize n, TOutputIterator result)

Description
Copies exactly n values from the range beginning at begin to the range beginning at result.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

copy_n_s

ETL extension

template <typename TInputIterator, typename TSize, typename TOutputIterator>
TOutputIterator copy_n_s(TInputIterator i_begin,
                         TSize n,
                         TOutputIterator o_begin, TOutputIterator o_end)

Description
A safer version that will stop copying when either n items have been copied or the output iterator reaches the end of its range.

template <typename TInputIterator, typename TSize1, typename TOutputIterator, typename TSize2>
TOutputIterator copy_n_s(TIterator i_begin,
                         TSize1 n1,
                         TOutputIterator o_begin,
                         TSize1 n2,)

Description
A safer version that will stop copying when either n1 or n2 items have been copied.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

copy_if

template <typename TIterator, typename TOutputIterator, typename TUnaryPredicate>
ETL_CONSTEXPR14
TOutputIterator copy_if(TIterator begin, TIterator end, TOutputIterator out, TUnaryPredicate predicate)

Description
Only copies the elements for which the predicate predicate returns true.

copy_if_s

ETL extension

template <typename TIterator, typename TOutputIterator, typename TUnaryPredicate>
ETL_CONSTEXPR14
TOutputIterator copy_if_s(TIterator i_begin,        TIterator i_end,
                          TOutputIterator o_begin,  TOutputIterator o_end,
                          TUnaryPredicate predicate)

Description
A safer version that will stop copying when either iterator reaches the end of its range.

copy_n_if

ETL extension

template <typename TIterator, typename TSize, typename TOutputIterator, typename TUnaryPredicate>
ETL_CONSTEXPR14
TOutputIterator copy_n_if(TIterator begin, TSize n, TOutputIterator out, TUnaryPredicate predicate)

Description
A combination of copy_if and copy_n.

reverse_copy

template <typename TIterator1, typename TIterator2>
TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db)

Description
Copies the elements from the range sb, se to another range beginning at db in such a way that the elements in the new range are in reverse order.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The STL is not in use.

copy_backward

template <typename TIterator1, typename TIterator2>
TIterator2 copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de)

Description
Copies the elements from the range, defined by sb, se to another range ending at db. The elements are copied in reverse order.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The STL is not in use.

count

template <typename TIterator, typename T>
typename iterator_traits<TIterator>::difference_type count(TIterator first, 
                                                           TIterator last, 
                                                           const T& value)

Description
Counts the elements that are equal to value.

count_if

template <typename TIterator, typename TUnaryPredicate>
typename iterator_traits<TIterator>::difference_type count_if(TIterator first, 
                                                              TIterator last, 
                                                              TUnaryPredicate predicate)

Description
Counts the elements where predicate returns true.

equal

template <typename TIterator1, typename TIterator2>
bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2)

Description
Returns true if the range [first1, last1) is equal to the range []first2, first2 + distance(first2, last2)).

lexicographical_compare

template <typename TIterator1, typename TIterator2>
bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
                             TIterator2 first2, TIterator2 last2)

Description
Checks if the range [first1, last1) is lexicographically less than the range [first2, last2), using the ’less-than’ operator.

template <typename TIterator1, typename TIterator2, typename TCompare>
bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
                             TIterator2 first2, TIterator2 last2,
                             TCompare compare)

Description
Checks if the range [first1, last1) is lexicographically less than the range [first2, last2), using compare.

make_heap

template <typename TIterator>
void make_heap(TIterator first, TIterator last)

Description
Makes a heap from the range [first, last).

template <typename TIterator, typename TCompare>
void make_heap(TIterator first, TIterator last, TCompare compare)

Description
Makes a heap from the range [first, last).
Uses compare to compare elements.

is_heap

template <typename TIterator>
bool is_heap(TIterator first, TIterator last)

Description
Returns true is the range [first, last) is a heap, otherwise false.

template <typename TIterator, typename TCompare>
bool is_heap(TIterator first, TIterator last, TCompare compare)

Description
Returns true is the range [first, last) is a heap, otherwise false.
Uses compare to compare elements.

pop_heap

template <typename TIterator>
void pop_heap(TIterator first, TIterator last)

Description
Removes the first element from the heap.

template <typename TIterator, typename TCompare>
void pop_heap(TIterator first, TIterator last, TCompare compare)

Description
Removes the first element from the heap.
Uses compare to compare elements.

push_heap

template <typename TIterator>
void push_heap(TIterator first, TIterator last)

Description
Inserts the element at the position last - 1 into the heap.

template <typename TIterator, typename TCompare>
void push_heap(TIterator first, TIterator last, TCompare compare)

Description
Inserts the element at the position last - 1 into the heap.
Uses compare to compare elements.

min

template <typename T>
ETL_CONSTEXPR const T& min(const T& a, const T& b)

Description
Returns the minimum of the two values.

template <typename T, typename TCompare>
ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare)

Description
Returns the value where compare returns true if a is less than b`.

max

template <typename T>
ETL_CONSTEXPR const T& max(const T& a, const T& b)

Description
Returns the maximum of the two values.

template <typename T, typename TCompare>
ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare)

Description
Returns the value where compare returns true if a is less than b.

minmax

template <typename T> 
pair<const T&, const T&> minmax(const T& a, const T& b)

Description
Returns the lesser and greater values.

template <typename T, typename TCompare> 
pair<const T&, const T&> minmax(const T& a, const T& b, TCompare compare)

Description
Returns the lesser and greater values using compare.

min_element

template <typename TIterator>
TIterator min_element(TIterator begin, TIterator end)

Description
Finds the smallest element in the range [begin, end).

template <typename TIterator, typename TCompare>
TIterator min_element(TIterator begin, TIterator end, TCompare compare)

Description
Finds the smallest element in the range [begin, end) using compare.

max_element

template <typename TIterator>
TIterator max_element(TIterator begin, TIterator end)

Description
Finds the greatest element in the range [begin, end).

template <typename TIterator, typename TCompare>
TIterator max_element(TIterator begin, TIterator end, TCompare compare)

Description
Finds the greatest element in the range [begin, end) using compare.

minmax_element

template <typename TIterator>
pair<TIterator, TIterator> minmax_element(TIterator begin, TIterator end)

Description
Finds the smallest and greatest element in the range [begin, end).

template <typename TIterator, typename TCompare>
pair<TIterator, TIterator> minmax_element(TIterator begin, TIterator end, TCompare compare)

Description
Finds the smallest and greatest element in the range [begin, end) using compare.

multimin

ETL extension
C++11 only
Variadic functions to return the minimum value, or iterator to value, from a variable length parameter list.

template <typename T, typename... Tx>
constexpr const T& multimin(const T& t, const Tx&... tx)

Description
Returns the minimum of the supplied arguments.

template <typename TCompare, typename T, typename... Tx>
constexpr const T& multimin_compare(TCompare compare, const T& t, const Tx&... tx)

Description
Returns the minimum of the supplied arguments. Uses compare to compare values.

template <typename TIterator, typename... TIteratorx>
constexpr const TIterator& multimin_iter(const TIterator& t, const TIteratorx&... tx)

Description
Returns the minimum of the dereferenced supplied arguments.

template <typename TCompare, typename TIterator, typename... TIteratorx>
constexpr const TIterator& multimin_iter_compare(TCompare compare, 
                                                 const TIterator& t, const TIteratorx&... tx)

Description
Returns the minimum of the dereferenced supplied arguments. Uses compare to compare values.

Example

int minimum;

minimum = etl::multimin(1, 2, 3, 4, 5, 6, 7, 8));
minimum = etl::multimin_compare(std::less<int>(), 1, 2, 3, 4, 5, 6, 7, 8));
minimum = etl::multimin_compare(std::greater<int>(), 1, 2, 3, 4, 5, 6, 7, 8));

int i[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };

int* p_minimum;

p_minimum = etl::multimin_iter(&i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6], &i[7]));
p_minimum = etl::multimin_iter_compare(std::less<int>(), 
                                       &i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6], &i[7]));
p_minimum = etl::multimin_iter_compare(std::greater<int>(), 
                                       &i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6], &i[7]));

multimax

ETL extension
C++11 only
Variadic functions to return the maximum value, or iterator to value, from a variable length parameter list.

template <typename T, typename... Tx>
constexpr const T& multimax(const T& t, const Tx&... tx)

Description
Returns the maximum of the supplied arguments.

template <typename TCompare, typename T, typename... Tx>
constexpr const T& multimax_compare(TCompare compare, const T& t, const Tx&... tx)

Description
Returns the maximum of the supplied arguments.
Uses compare to compare values.

template <typename TIterator, typename... TIteratorx>
constexpr const TIterator& multimax_iter(const TIterator& t, const TIteratorx&... tx)

Description
Returns the maximum of the dereferenced supplied arguments.

template <typename TCompare, typename TIterator, typename... TIteratorx>
constexpr const TIterator& multimax_iter_compare(TCompare             compare, 
                                                 const TIterator&     t, 
                                                 const TIteratorx&... tx)

Description
Returns the maximum of the dereferenced supplied arguments.
Uses compare to compare values.

Example

int maximum;

maximum = etl::multimax(1, 2, 3, 4, 5, 6, 7, 8));
maximum = etl::multimax_compare(std::less<int>(), 1, 2, 3, 4, 5, 6, 7, 8));
maximum = etl::multimax_compare(std::greater<int>(), 1, 2, 3, 4, 5, 6, 7, 8));

int i[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };

int* p_maximum;

p_maximum = etl::multimax_iter(&i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6], &i[7]));
p_maximum = etl::multimax_iter_compare(std::less<int>(), 
                                       &i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6], &i[7]));
p_maximum = etl::multimax_iter_compare(std::greater<int>(), 
                                       &i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6], &i[7]));

move

template <typename TIterator1, typename TIterator2>
TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db)

Description
Moves the elements in the range sb, se to another range beginning at db.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

move_s

ETL extension

template <typename TInputIterator, typename TOutputIterator>
TOutputIterator move_s(TInputIterator  i_begin, TInputIterator  i_end,
                       TOutputIterator o_begin, TOutputIterator o_end)

Description
A safer four parameter version that will stop moving when either iterator reaches the end of its range.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

move_backward

template <typename TIterator1, typename TIterator2>
TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)

Description
Moves the elements in the range sb, se to another range ending at de.
The elements are moved in reverse order.

constexpr
This function is constexpr under the following conditions.

The STL is in use and C++20 is supported.
The iterator is non-pointer or the type is not trivially copyable and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, built-in memcpy is supported, and C++14 is supported.
The iterator is a pointer, the type is trivially copyable, ETL_FORCE_CONSTEXPR_ALGORITHMS is defined as 1, and C++14 is supported.

reverse

template <typename TIterator>
void reverse(TIterator b, TIterator e)

Description
Reverses the order of the elements in the range b, e.

for_each_if

ETL extension

template <typename TIterator, typename TUnaryFunction, typename TUnaryPredicate>
TUnaryFunction for_each_if(TIterator       begin,
                           const TIterator end,
                           TUnaryFunction  function,
                           TUnaryPredicate predicate)

Description
Applies function to each element if predicate returns true.

for_each_n

ETL extension

template <typename TIterator, typename TSize, typename TUnaryFunction>
TIterator for_each_n(TIterator       begin,
                     TSize           n,
                     TUnaryFunction  function)

Description
Applies function to n elements, starting from begin.

for_each_n_if

ETL extension

template <typename TIterator, typename TSize, typename TUnaryFunction, typename TUnaryPredicate>
TIterator for_each_n_if(TIterator       begin,
                        TSize           n,
                        TUnaryFunction  function,
                        TUnaryPredicate predicate)

Description
Combination of for_each_if and for_each_n.

fill

template <typename TIterator, typename TValue>
void fill(TIterator first, TIterator last, const TValue& value)

Description
Assigns the given value to the elements in the range first, last.

fill_n

template <typename TIterator, typename TSize, typename TValue>
TIterator fill_n(TIterator first, TSize count, const TValue& value)

Description
Assigns the given value to the first count elements in the range beginning at first.

find

template <typename TIterator, typename T>
TIterator find(TIterator first, TIterator last, const T& value)

Description
Searches for an element equal to value.

find_end

template <typename TIterator1, typename TIterator2>
TIterator1 find_end(TIterator1 b, TIterator1 e,
                    TIterator2 sb, TIterator2 se)

Description
Searches for the last occurrence of the sequence b, e in the range sb, be.

template <typename TIterator1, typename TIterator2, typename TPredicate>
TIterator1 find_end(TIterator1 b, TIterator1 e,
                    TIterator2 sb, TIterator2 se,
                    TPredicate predicate)

Description
Searches for the last occurrence of the sequence b, e in the range sb, be, using predicate.

find_if

template <typename TIterator, typename TUnaryPredicate>
TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate)

Description
Searches for the first element that satisfies the predicate.

find_if_not

template <typename TIterator, typename TUnaryPredicate>
TIterator find_if_not(TIterator begin, TIterator end, TUnaryPredicate predicate)

Description
Searches for the first element that does not satisfy the predicate.

lower_bound

template <typename TIterator, typename TValue>
TIterator lower_bound(TIterator first, TIterator last, const TValue& value)

Description
Searches for the first element in the range [first, last) which is *not ordered before value.

Return
An iterator to the element, or last if not found.

template <typename TIterator, typename TValue, typename TCompare>
TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare)

Description
Searches for the first element in the range [first, last) which is *not ordered before value.
Uses compare to compare elements.

Return
An iterator to the element, or last if not found.

upper_bound

template <typename TIterator, typename TValue>
TIterator upper_bound(TIterator first, TIterator last, const TValue& value)

Description
Searches for the first element in the range [first, last) which is ordered after value.

Return
An iterator to the element, or last if not found.

template <typename TIterator, typename TValue, typename TCompare>
TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare)

Description
Searches for the first element in the range [first, last) which is ordered after value.
Uses compare to compare elements.

Return
An iterator to the element, or last if not found.

equal_range

template <typename TIterator, typename TValue>
pair<TIterator, TIterator> equal_range(TIterator first, TIterator last, const TValue& value)

Description
Returns a range containing all elements equivalent to value in the range [first, last).

Return
A pair containing a pair of iterators.

first is is the result of lower_bound(first, last). last is is the result of upper_bound(first, last).

template <typename TIterator, typename TValue, typename TCompare>
pair<TIterator, TIterator> equal_range(TIterator first, TIterator last, 
                                       const TValue& value, TCompare compare)

Description
Returns a range containing all elements equivalent to value in the range [first, last).
Uses compare to compare elements.

Return
A pair containing a pair of iterators.

first is is the result of lower_bound(first, last). last is is the result of upper_bound(first, last).

binary_find

ETL extension

template <typename TIterator, typename TValue>
TIterator binary_find(TIterator     begin,
                      TIterator     end,
                      const TValue& value)

Description
Finds the first item in a sorted container that matches the value.
Returns an iterator to the value or end.

template <typename TIterator, typename TValue, typename TBinaryPredicate, typename TBinaryEquality>
TIterator binary_find(TIterator        begin,
                      TIterator        end,
                      const TValue&    value,
                      TBinaryPredicate predicate,
                      TBinaryEquality  equality)

Description
Finds the first item in a sorted container that matches the value.
Returns an iterator to the value or end.
Comparison and equality predicates are supplied.

search

template <typename TIterator1, typename TIterator2>
TIterator1 search(TIterator1 first, TIterator1 last, 
                  TIterator2 search_first, TIterator2 search_last)

Description
Searches for the first occurrence of the sequence of elements first, last in the range search_first, search_last.

template <typename TIterator1, typename TIterator2, typename TCompare>
TIterator1 search(TIterator1 first, TIterator1 last, 
                  TIterator2 search_first, TIterator2 search_last,
                  TCompare compare)

Description
Searches for the first occurrence of the sequence of elements first, last in the range search_first, search_last
Uses compare to check equality of the values.

binary_search

template <typename TIterator, typename T>
bool binary_search(TIterator first, TIterator last, const T& value)

Description
Checks if an element equivalent to value appears within the range [first, last).

template <typename TIterator, typename T, typename Compare>
bool binary_search(TIterator first, TIterator last, const T& value, Compare compare)

Description
Checks if an element equivalent to value appears within the range [first, last). Uses compare to check equality of the values.

all_of

template <typename TIterator, typename TUnaryPredicate>
bool all_of(TIterator begin, TIterator end, TUnaryPredicate predicate)

Description
Checks if predicate returns true for all elements in the range [begin, end).

any_of

template <typename TIterator, typename TUnaryPredicate>
bool any_of(TIterator begin, TIterator end, TUnaryPredicate predicate)

Description
Checks if predicate returns true for at least one element in the range [begin, end).

none_of

template <typename TIterator, typename TUnaryPredicate>
bool none_of(TIterator begin, TIterator end, TUnaryPredicate predicate)

Description
Checks if predicate returns true for no elements in the range [begin, end).

is_permutation

template <typename TIterator1, typename TIterator2>
bool is_permutation(TIterator1 begin1, 
                    TIterator1 end1, 
                    TIterator2 begin2)

Description
Returns true if there exists a permutation of the elements in the range [begin1, end1) that makes that range equal to the second range.

template <typename TIterator1, typename TIterator2>
bool is_permutation(TIterator1 begin1, 
                    TIterator1 end1, 
                    TIterator2 begin2, 
                    TIterator2 end2)

Description
Returns true if there exists a permutation of the elements in the range [begin1, end1) that makes that range equal to the second range.

template <typename TIterator1, 
          typename TIterator2, 
          typename TBinaryPredicate>
bool is_permutation(TIterator1       begin1, 
                    TIterator1       end1, 
                    TIterator2       begin2, 
                    TBinaryPredicate predicate)

Description
Returns true if there exists a permutation of the elements in the range [begin1, end1) that makes that range equal to the second range.
Uses predicate to checks elements in the range.

template <typename TIterator1, 
          typename TIterator2, 
          typename TBinaryPredicate>
bool is_permutation(TIterator1       begin1, 
                    TIterator1       end1, 
                    TIterator2       begin2, 
                    TIterator2       end2, 
                    TBinaryPredicate predicate)

is_partitioned

template <typename TIterator, typename TUnaryPredicate>
bool is_partitioned(TIterator begin, 
                    TIterator end, 
                    TUnaryPredicate predicate)

Description
Returns true if all elements in the range [begin, end) that satisfy the predicate appear before all elements that don’t. Also returns true if [begin, end) is empty.

partition_point

template <typename TIterator, typename TUnaryPredicate>
TIterator partition_point(TIterator begin, 
                          TIterator end,  
                          TUnaryPredicate predicate)

Description
Examines the partitioned range [begin, end) and locates the end of the first partition according to predicate.

partition_copy

template <typename TSource, 
          typename TDestinationTrue, 
          typename TDestinationFalse, 
          typename TUnaryPredicate>
pair<TDestinationTrue, TDestinationFalse> partition_copy(TSource           begin,
                                                         TSource           end, 
                                                         TDestinationTrue  destination_true,
                                                         TDestinationFalse destination_false,
                                                         TUnaryPredicate   predicate)

Description
Copies the elements from the range [begin, end) to two different ranges depending on the value returned by the predicate.
The elements that satisfy predicate are copied to the range beginning at destination_true.
The rest of the elements are copied to the range beginning at destination_false.

partition_transform

ETL extension

One input range

template <typename TSource, 
          typename TDestinationTrue, 
          typename TDestinationFalse,
          typename TUnaryFunctionTrue, 
          typename TUnaryFunctionFalse, 
          typename TUnaryPredicate>
pair<TDestinationTrue, TDestinationFalse>
  partition_transform(TSource             begin,
                      TSource             end,
                      TDestinationTrue    destination_true,
                      TDestinationFalse   destination_false,
                      TUnaryFunctionTrue  function_true,
                      TUnaryFunctionFalse function_false,
                      TUnaryPredicate     predicate)

Description
Transforms data from the source to one of two destinations.
If predicate returns true then the source data if modified by function_true and stored in destination_true.
If predicate returns false then the source data if modified by function_false and stored in destination_false.

Two input ranges

template <typename TSource1,
          typename TSource2, 
          typename TDestinationTrue, 
          typename TDestinationFalse,
          typename TUnaryFunctionTrue, 
          typename TUnaryFunctionFalse, 
          typename TUnaryPredicate>
pair<TDestinationTrue, TDestinationFalse>
  partition_transform(TSource1             begin1,
                      TSource1             end1,
                      TSource2             begin2,
                      TDestinationTrue     destination_true,
                      TDestinationFalse    destination_false,
                      TBinaryFunctionTrue  function_true,
                      TBinaryFunctionFalse function_false,
                      TBinaryPredicate     predicate)

rotate

template <typename TIterator>
TIterator rotate(TIterator first, TIterator middle, TIterator last)

Description
Performs a left rotation on the range of elements.

transform_s

ETL extension

template <typename TIterator, 
          typename TOutputIterator, 
          typename TUnaryPredicate>
void transform_s(TIterator       i_begin,        
                 TIterator       i_end,
                 TOutputIterator o_begin,  
                 TOutputIterator o_end,
                 TUnaryFunction  function)

Description
A safer version that will stop transforming when either iterator reaches the end of its range.

transform_n

ETL extension

One input range

template <typename TInputIterator, 
          typename TSize, 
          typename TOutputIterator, 
          typename TUnaryFunction>
void transform_n(TInputIterator  i_begin,
                 TSize           n,
                 TOutputIterator o_begin,
                 TUnaryFunction  function)

Description
Transform over n elements.

Two input ranges

template <typename TInputIterator1,
          typename TInputIterator2, 
          typename TSize, 
          typename TOutputIterator, 
          typename TBinaryFunction>
void transform_n(TInputIterator1 i_begin1,
                 TInputIterator2 i_begin2,
                 TSize           n,
                 TOutputIterator o_begin,
                 TBinaryFunction function)

Description
Transform over n elements.

transform_if

ETL extension

One input range

template <typename TInputIterator, 
          typename TOutputIterator, 
          typename TUnaryFunction, 
          typename TUnaryPredicate>
TOutputIterator transform_if(TInputIterator  i_begin,  
                             TInputIterator  i_end,
                             TOutputIterator o_begin, 
                             TUnaryFunction  function,
                             TUnaryPredicate predicate)

Description
Transforms data from the source based on a predicate.
If predicate returns true then the source data if modified by function and stored in the output range.
If predicate returns false then the source data is ignored.

Two input ranges

template <typename TInputIterator1, 
          typename TInputIterator2,
          typename TOutputIterator, 
          typename TBinaryFunction, 
          typename TBinaryPredicate>
TOutputIterator transform_if(TInputIterator1  i_begin1,
                             TInputIterator1  i_end1,
                             TInputIterator2  i_begin2, 
                             TOutputIterator  o_begin,
                             TBinaryFunction  function,
                             TBinaryPredicate predicate)

transform_n_if

ETL extension

One input range

template <typename TInputIterator,
          typename TSize,
          typename TOutputIterator, 
          typename TUnaryFunction, 
          typename TUnaryPredicate>
TOutputIterator transform_if(TInputIterator  i_begin,  
                             TSize           n,
                             TOutputIterator o_begin, 
                             TUnaryFunction  function,
                             TUnaryPredicate predicate)

Description
Transforms data from the source based on a predicate for n items.
If predicate returns true then the source data if modified by function and stored in the output range.
If predicate returns false then the source data is ignored.

Two input ranges

template <typename TInputIterator1, 
          typename TInputIterator2,
          typename TSize,
          typename TOutputIterator, 
          typename TBinaryFunction, 
          typename TBinaryPredicate>
TOutputIterator transform_if(TInputIterator1  i_begin1,
                             TSize            n,
                             TInputIterator2  i_begin2, 
                             TOutputIterator  o_begin,
                             TBinaryFunction  function,
                             TBinaryPredicate predicate)

shell_sort

ETL extension
https://en.wikipedia.org/wiki/Shellsort

template <typename TIterator>
void shell_sort(TIterator first, TIterator last)

Description
Sorts a range using the shell sort algorithm.

template <typename TIterator, typename TCompare>
void shell_sort(TIterator first, TIterator last, TCompare compare)

Description
Sorts a range using the shell sort algorithm, using compare.

insertion_sort

ETL extension
https://en.wikipedia.org/wiki/Insertion_sort

template <typename TIterator>
void insertion_sort(TIterator first, TIterator last)

Description
Sorts a range using the insertion sort algorithm.

template <typename TIterator, typename TCompare>
void insertion_sort(TIterator first, TIterator last, TCompare compare)

Description
Sorts a range using the insertion sort algorithm.

heap_sort

ETL extension
https://en.wikipedia.org/wiki/Heapsort

template <typename TIterator>
void heap_sort(TIterator first, TIterator last)

Sorts a range using the heap sort algorithm.
Since: 16.2.0

template <typename TIterator, typename TCompare>
void heap_sort(TIterator first, TIterator last, TCompare compare)

Description Sorts a range using the heap sort algorithm, using compare. Since: 16.2.0

selection_sort

ETL extension
https://en.wikipedia.org/wiki/Selectionsort

template <typename TIterator>
void selection_sort(TIterator first, TIterator last)

Description
Sorts a range using the selection sort algorithm.
From: 20.7.0

template <typename TIterator, typename TCompare>
void selection_sort(TIterator first, TIterator last, TCompare compare)

Description
Sorts a range using the selection sort algorithm.
From: 20.7.0

sort

template <typename TIterator>
void sort(TIterator first, TIterator last)

Description
If ETL_NO_STL is defined then uses etl::shell_sort, otherwise calls std::sort.

template <typename TIterator, typename TCompare>
void sort(TIterator first, TIterator last, TCompare compare)

Description
If ETL_NO_STL is defined then uses etl::shell_sort, otherwise calls std::sort.

stable_sort

template <typename TIterator>
void stable_sort(TIterator first, TIterator last)

Description
If ETL_NO_STL is defined then uses etl::insertion_sort, otherwise calls std::stable_sort.

template <typename TIterator, typename TCompare>
void stable_sort(TIterator first, TIterator last, TCompare compare)

Description
If ETL_NO_STL is defined then uses etl::insertion_sort, otherwise calls std::stable_sort.

is_sorted

template <typename TIterator>
bool is_sorted(TIterator begin, TIterator end)

Description
Returns true is the range is sorted.

template <typename TIterator, typename TCompare>
bool is_sorted(TIterator begin, TIterator end, TCompare compare)

Description
Returns true is the range is sorted.

is_sorted_until

template <typename TIterator>
TIterator is_sorted_until(TIterator begin, TIterator end)

Description
Returns an iterator to the first element that is not sorted

template <typename TIterator, typename TCompare>
TIterator is_sorted_until(TIterator begin, TIterator end, TCompare compare)

Description
Returns an iterator to the first element that is not sorted

clamp

template <typename T>
ETL_CONSTEXPR const T& clamp(const T& value, const T& low, const T& high )

Description
Clamps value between two limits.

template <typename T, typename TCompare>
ETL_CONSTEXPR const T& clamp(const T& value, const T& low, const T& high, TCompare compare)

Description
Clamps value between two limits, using compare.

accumulate

template <typename TIterator, typename T>
ETL_CONSTEXPR14 T accumulate(TIterator first, TIterator last, T sum)

Computes the sum of the given sum and the elements in the range first, last.

template <typename TIterator, typename T, typename TBinaryOperation>
ETL_CONSTEXPR14 T accumulate(TIterator first, TIterator last, T init, TBinaryOperation operation)

Computes the sum of the given init and the elements in the range first, last. Uses operation to compute the final value.

remove

template <typename TIterator, typename T>
TIterator remove(TIterator first, TIterator last, const T& value)

Description
Removes all elements that are equal to value.

remove_if

template <typename TIterator, typename TUnaryPredicate>
TIterator remove_if(TIterator first, TIterator last, TPredicate predicate)

Description
Removes all elements that satisfy predicate.

alignment