algorithm

Algorithms that operate on ranges. More...

Classes
struct	in_fun_result< I, F >

Functions
template<typename InputIt, typename OutputIt>
constexpr auto	copy (InputIt first, InputIt last, OutputIt destination) -> OutputIt
	Copies the elements in the range, defined by [first, last), to another range beginning at destination.
template<typename BidirIt1, typename BidirIt2>
constexpr auto	copy_backward (BidirIt1 first, BidirIt1 last, BidirIt2 dLast) -> BidirIt2
	Copies the elements from the range, defined by [first, last), to another range ending at dLast. The elements are copied in reverse order (the last element is copied first), but their relative order is preserved.
template<typename InIt, typename OutIt, typename Pred>
constexpr auto	copy_if (InIt first, InIt last, OutIt dFirst, Pred pred) -> OutIt
	Copies the elements in the range, defined by [first, last), to another range beginning at destination.
template<typename InputIt, typename Size, typename OutputIt>
constexpr auto	copy_n (InputIt first, Size count, OutputIt result) -> OutputIt
	Copies exactly count values from the range beginning at first to the range beginning at result. Formally, for each integer 0 <= i < count, performs *(result + i) = *(first + i). Overlap of ranges is formally permitted, but leads to unpredictable ordering of the results.
template<typename InputIt, typename T>
constexpr auto	count (InputIt first, InputIt last, T const &value) -> typename iterator_traits< InputIt >::difference_type
	Returns the number of elements in the range [first, last) satisfying specific criteria. Counts the elements that are equal to value.
template<typename InputIt, typename Predicate>
constexpr auto	count_if (InputIt first, InputIt last, Predicate p) -> typename iterator_traits< InputIt >::difference_type
	Returns the number of elements in the range [first, last) satisfying specific criteria. Counts elements for which predicate p returns true.
template<typename InputIt1, typename InputIt2>
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2) -> bool
template<typename InputIt1, typename InputIt2>
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) -> bool
template<typename InputIt1, typename InputIt2, typename Predicate>
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Predicate p) -> bool
template<typename InputIt1, typename InputIt2, typename Predicate>
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, Predicate p) -> bool
	Returns true if the range [first1, last1) is equal to the range [first2, first2 + (last1 - first1)), and false otherwise.
template<typename ForwardIt, typename T>
constexpr auto	equal_range (ForwardIt first, ForwardIt last, T const &value) -> pair< ForwardIt, ForwardIt >
template<typename ForwardIt, typename T, typename Compare>
constexpr auto	equal_range (ForwardIt first, ForwardIt last, T const &value, Compare comp) -> pair< ForwardIt, ForwardIt >
	Returns a range containing all elements equivalent to value in the range [first, last).
template<typename RandomIt>
constexpr auto	exchange_sort (RandomIt first, RandomIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename RandomIt, typename Compare>
constexpr auto	exchange_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename ForwardIt, typename T>
constexpr auto	fill (ForwardIt first, ForwardIt last, T const &value) -> void
	Assigns the given value to the elements in the range [first, last).
template<typename OutputIt, typename Size, typename T>
constexpr auto	fill_n (OutputIt first, Size count, T const &value) -> OutputIt
	Assigns the given value to the first count elements in the range beginning at first if count > 0. Does nothing otherwise.
template<typename InputIt, typename T>
constexpr auto	find (InputIt first, InputIt last, T const &value) noexcept -> InputIt
	Searches for an element equal to value.
template<typename ForwardIt1, typename ForwardIt2>
constexpr auto	find_end (ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast) -> ForwardIt1
template<typename ForwardIt1, typename ForwardIt2, typename Predicate>
constexpr auto	find_end (ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast, Predicate p) -> ForwardIt1
	Searches for the last occurrence of the sequence [sFirst, sLast) in the range [first, last). Elements are compared using the given binary predicate p.
template<typename InputIt, typename ForwardIt>
constexpr auto	find_first_of (InputIt first, InputIt last, ForwardIt sFirst, ForwardIt sLast) -> InputIt
	Searches the range [first, last) for any of the elements in the range [sFirst, sLast).
template<typename InputIt, typename ForwardIt, typename Predicate>
constexpr auto	find_first_of (InputIt first, InputIt last, ForwardIt sFirst, ForwardIt sLast, Predicate pred) -> InputIt
	Searches the range [first, last) for any of the elements in the range [sFirst, sLast). Elements are compared using the given binary predicate pred.
template<typename InputIt, typename Predicate>
constexpr auto	find_if (InputIt first, InputIt last, Predicate pred) noexcept -> InputIt
	Searches for an element for which predicate p returns true.
template<typename InputIt, typename Predicate>
constexpr auto	find_if_not (InputIt first, InputIt last, Predicate pred) noexcept -> InputIt
	Searches for an element for which predicate q returns false.
template<typename InputIt, typename UnaryFunc>
constexpr auto	for_each (InputIt first, InputIt last, UnaryFunc f) noexcept -> UnaryFunc
	Applies the given function object f to the result of dereferencing every iterator in the range [first, last) in order.
template<typename InputIt, typename Size, typename UnaryFunc>
constexpr auto	for_each_n (InputIt first, Size n, UnaryFunc f) noexcept -> InputIt
	Applies the given function object f to the result of dereferencing every iterator in the range [first, first + n] in order.
template<typename ForwardIt, typename Generator>
constexpr auto	generate (ForwardIt first, ForwardIt last, Generator g) -> void
	Assigns each element in range [first, last) a value generated by the given function object g.
template<typename OutputIt, typename SizeT, typename Generator>
constexpr auto	generate_n (OutputIt first, SizeT count, Generator g) -> OutputIt
	Assigns values, generated by given function object g, to the first count elements in the range beginning at first, if count > 0. Does nothing otherwise.
template<typename BidirIt>
constexpr auto	gnome_sort (BidirIt first, BidirIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename BidirIt, typename Compare>
constexpr auto	gnome_sort (BidirIt first, BidirIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename InputIt1, typename InputIt2>
constexpr auto	includes (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) -> bool
template<typename InputIt1, typename InputIt2, typename Compare>
constexpr auto	includes (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp) -> bool
	Returns true if the sorted range [first2, last2) is a subsequence of the sorted range [first1, last1). Both ranges must be sorted.
template<typename BidirIt, typename Compare>
constexpr auto	inplace_merge (BidirIt begin, BidirIt mid, BidirIt end, Compare comp) -> void
	Merges two consecutive sorted ranges [first, middle) and [middle, last) into one sorted range [first, last).
template<typename BidirIt>
constexpr auto	inplace_merge (BidirIt first, BidirIt mid, BidirIt last) -> void
template<typename RandomIt>
constexpr auto	insertion_sort (RandomIt first, RandomIt last) -> void
template<typename RandomIt, typename Compare>
constexpr auto	insertion_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.
template<typename InputIt, typename Predicate>
constexpr auto	is_partitioned (InputIt first, InputIt last, Predicate p) -> bool
	Returns true if all elements in the range [first, last) that satisfy the predicate p appear before all elements that don't. Also returns true if the range is empty.
template<typename ForwardIt1, typename ForwardIt2>
constexpr auto	is_permutation (ForwardIt1 first, ForwardIt1 last, ForwardIt2 first2) -> bool
	Returns true if there exists a permutation of the elements in the range [first1, last1) that makes that range equal to the range [first2, last2), where last2 denotes first2 + (last1 - first1) if it was not given.
template<typename ForwardIt1, typename ForwardIt2>
constexpr auto	is_permutation (ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2) -> bool
template<typename ForwardIt>
constexpr auto	is_sorted (ForwardIt first, ForwardIt last) -> bool
	Checks if the elements in range [first, last) are sorted in non-descending order.
template<typename ForwardIt, typename Compare>
constexpr auto	is_sorted (ForwardIt first, ForwardIt last, Compare comp) -> bool
template<typename ForwardIt>
constexpr auto	is_sorted_until (ForwardIt first, ForwardIt last) -> ForwardIt
	Examines the range [first, last) and finds the largest range beginning at first in which the elements are sorted in non-descending order.
template<typename ForwardIt, typename Compare>
constexpr auto	is_sorted_until (ForwardIt first, ForwardIt last, Compare comp) -> ForwardIt
template<typename ForwardIt1, typename ForwardIt2>
constexpr auto	iter_swap (ForwardIt1 a, ForwardIt2 b) -> void
	Swaps the values of the elements the given iterators are pointing to.
template<typename InputIt1, typename InputIt2>
constexpr auto	lexicographical_compare (InputIt1 f1, InputIt1 l1, InputIt2 f2, InputIt2 l2) -> bool
template<typename InputIt1, typename InputIt2, typename Compare>
constexpr auto	lexicographical_compare (InputIt1 f1, InputIt1 l1, InputIt2 f2, InputIt2 l2, Compare comp) -> bool
	Checks if the first range [f1, l1) is lexicographically less than the second range [f2, l2).
template<typename ForwardIt, typename T>
constexpr auto	lower_bound (ForwardIt first, ForwardIt last, T const &value) noexcept -> ForwardIt
template<typename ForwardIt, typename T, typename Compare>
constexpr auto	lower_bound (ForwardIt first, ForwardIt last, T const &value, Compare comp) noexcept -> ForwardIt
	Returns an iterator pointing to the first element in the range [first, last) that is not less than (i.e. greater or equal to) value, or last if no such element is found.
template<typename Type>
constexpr auto	max (Type const &a, Type const &b) noexcept -> Type const &
	Returns the greater of a and b.
template<typename Type, typename Compare>
constexpr auto	max (Type const &a, Type const &b, Compare comp) noexcept -> Type const &
	Returns the greater of a and b, using a compare function.
template<typename ForwardIt>
constexpr auto	max_element (ForwardIt first, ForwardIt last) noexcept -> ForwardIt
	Finds the greatest element in the range [first, last). Elements are compared using operator<.
template<typename ForwardIt, typename Compare>
constexpr auto	max_element (ForwardIt first, ForwardIt last, Compare comp) -> ForwardIt
	Finds the greatest element in the range [first, last). Elements are compared using the given binary comparison function comp.
template<typename InputIt1, typename InputIt2, typename OutputIt>
constexpr auto	merge (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination) -> OutputIt
template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>
constexpr auto	merge (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Merges two sorted ranges [first1, last1) and [first2, last2) into one sorted range beginning at destination.
template<typename Type>
constexpr auto	min (Type const &a, Type const &b) noexcept -> Type const &
	Returns the smaller of a and b.
template<typename Type, typename Compare>
constexpr auto	min (Type const &a, Type const &b, Compare comp) noexcept -> Type const &
	Returns the smaller of a and b, using a compare function.
template<typename ForwardIt>
constexpr auto	min_element (ForwardIt first, ForwardIt last) noexcept -> ForwardIt
	Finds the smallest element in the range [first, last). Elements are compared using operator<.
template<typename ForwardIt, typename Compare>
constexpr auto	min_element (ForwardIt first, ForwardIt last, Compare comp) -> ForwardIt
	Finds the smallest element in the range [first, last). Elements are compared using the given binary comparison function comp.
template<typename T>
constexpr auto	minmax (T const &a, T const &b) -> pair< T const &, T const & >
	Returns the lowest and the greatest of the given values.
template<typename T, typename Compare>
constexpr auto	minmax (T const &a, T const &b, Compare comp) -> pair< T const &, T const & >
	Returns the lowest and the greatest of the given values.
template<typename ForwardIt>
constexpr auto	minmax_element (ForwardIt first, ForwardIt last) -> pair< ForwardIt, ForwardIt >
	Finds the smallest and greatest element in the range [first, last).
template<typename ForwardIt, typename Compare>
constexpr auto	minmax_element (ForwardIt first, ForwardIt last, Compare comp) -> pair< ForwardIt, ForwardIt >
	Finds the smallest and greatest element in the range [first, last).
template<typename InputIt1, typename InputIt2, typename Predicate>
constexpr auto	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, Predicate pred) -> pair< InputIt1, InputIt2 >
	Returns the first mismatching pair of elements from two ranges: one defined by [first1, last1) and another defined by [first2,last2). If last2 is not provided (overloads (1-4)), it denotes first2 + (last1 - first1). Elements are compared using the given binary predicate pred.
template<typename InputIt, typename OutputIt>
constexpr auto	move (InputIt first, InputIt last, OutputIt destination) -> OutputIt
	Moves the elements in the range [first, last), to another range beginning at destination, starting from first and proceeding to last - 1. After this operation the elements in the moved-from range will still contain valid values of the appropriate type, but not necessarily the same values as before the move.
template<typename BidirIt1, typename BidirIt2>
constexpr auto	move_backward (BidirIt1 first, BidirIt1 last, BidirIt2 destination) -> BidirIt2
	Moves the elements from the range [first, last), to another range ending at destination. The elements are moved in reverse order (the last element is moved first), but their relative order is preserved.
template<typename InputIt, typename Predicate>
constexpr auto	none_of (InputIt first, InputIt last, Predicate p) -> bool
	Checks if unary predicate p returns true for no elements in the range [first, last).
template<typename RandomIt, typename Compare>
constexpr auto	nth_element (RandomIt first, RandomIt nth, RandomIt last, Compare comp) -> void
	nth_element is a partial sorting algorithm that rearranges elements in [first, last) such that:
template<typename RandomIt, typename Compare>
constexpr auto	partial_sort (RandomIt first, RandomIt middle, RandomIt last, Compare comp) -> void
	Rearranges elements such that the range [first, middle) contains the sorted middle - first smallest elements in the range [first, last). The order of equal elements is not guaranteed to be preserved. The order of the remaining elements in the range [middle, last) is unspecified.
template<typename ForwardIt, typename Predicate>
constexpr auto	partition (ForwardIt first, ForwardIt last, Predicate p) -> ForwardIt
	Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is not preserved.
template<typename InputIt, typename OutputIt1, typename OutputIt2, typename Predicate>
constexpr auto	partition_copy (InputIt first, InputIt last, OutputIt1 destinationTrue, OutputIt2 destinationFalse, Predicate p) -> pair< OutputIt1, OutputIt2 >
	Copies the elements from the range [first, last) to two different ranges depending on the value returned by the predicate p. The elements that satisfy the predicate p are copied to the range beginning at destination_true. The rest of the elements are copied to the range beginning at destination_false.
template<typename ForwardIt, typename Predicate>
constexpr auto	partition_point (ForwardIt first, ForwardIt last, Predicate p) -> ForwardIt
	Examines the partitioned (as if by partition) range [first, last) and locates the end of the first partition, that is, the first element that does not satisfy p or last if all elements satisfy p.
template<typename ForwardIt, typename T>
constexpr auto	remove (ForwardIt first, ForwardIt last, T const &value) -> ForwardIt
	Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.
template<typename InputIt, typename OutputIt, typename T>
constexpr auto	remove_copy (InputIt first, InputIt last, OutputIt destination, T const &value) -> OutputIt
	Copies elements from the range [first, last), to another range beginning at destination, omitting the elements which satisfy specific criteria. Source and destination ranges cannot overlap. Ignores all elements that are equal to value.
template<typename InputIt, typename OutputIt, typename Predicate>
constexpr auto	remove_copy_if (InputIt first, InputIt last, OutputIt destination, Predicate p) -> OutputIt
	Copies elements from the range [first, last), to another range beginning at destination, omitting the elements which satisfy specific criteria. Source and destination ranges cannot overlap. Ignores all elements for which predicate p returns true.
template<typename ForwardIt, typename Predicate>
constexpr auto	remove_if (ForwardIt first, ForwardIt last, Predicate pred) -> ForwardIt
	Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.
template<typename ForwardIt, typename T>
constexpr auto	replace (ForwardIt first, ForwardIt last, T const &oldValue, T const &newValue) -> void
	Replaces all elements satisfying specific criteria with new_value in the range [first, last). Replaces all elements that are equal to old_value.
template<typename ForwardIt, typename Predicate, typename T>
constexpr auto	replace_if (ForwardIt first, ForwardIt last, Predicate p, T const &newValue) -> void
	Replaces all elements satisfying specific criteria with new_value in the range [first, last). Replaces all elements for which predicate p returns true.
template<typename BidirIt>
constexpr auto	reverse (BidirIt first, BidirIt last) -> void
	Reverses the order of the elements in the range [first, last).
template<typename BidirIt, typename OutputIt>
constexpr auto	reverse_copy (BidirIt first, BidirIt last, OutputIt destination) -> OutputIt
	Copies the elements from the range [first, last) to another range beginning at d_first in such a way that the elements in the new range are in reverse order.
template<typename ForwardIt>
constexpr auto	rotate (ForwardIt first, ForwardIt nFirst, ForwardIt last) -> ForwardIt
	Performs a left rotation on a range of elements.
template<typename ForwardIt, typename OutputIt>
constexpr auto	rotate_copy (ForwardIt first, ForwardIt nFirst, ForwardIt last, OutputIt destination) -> OutputIt
	Copies the elements from the range [first, last), to another range beginning at destination in such a way, that the element nFirst becomes the first element of the new range and nFirst - 1 becomes the last element.
template<typename ForwardIt>
constexpr auto	shift_left (ForwardIt first, ForwardIt const last, typename iterator_traits< ForwardIt >::difference_type n) -> ForwardIt
	Shifts the elements in the range [first, last) by n positions.
template<typename BidiIt>
constexpr auto	shift_right (BidiIt first, BidiIt last, typename etl::iterator_traits< BidiIt >::difference_type n) -> BidiIt
	Shifts the elements in the range [first, last) by n positions.
template<typename BidirIt, typename Predicate>
constexpr auto	stable_partition (BidirIt f, BidirIt l, Predicate p) -> BidirIt
	Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is preserved.
template<typename ForwardIt1, typename ForwardIt2>
constexpr auto	swap_ranges (ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2) -> ForwardIt2
	Exchanges elements between range [first1 ,last1) and another range starting at first2.
template<typename ForwardIt, typename Predicate>
constexpr auto	adjacent_find (ForwardIt first, ForwardIt last, Predicate pred) -> ForwardIt
	Searches the range [first, last) for two consecutive equal elements. Elements are compared using the given binary predicate p.
template<typename ForwardIt>
constexpr auto	adjacent_find (ForwardIt first, ForwardIt last) -> ForwardIt
	Searches the range [first, last) for two consecutive equal elements. Elements are compared using the given binary predicate p.
template<typename InputIt, typename Predicate>
constexpr auto	all_of (InputIt first, InputIt last, Predicate p) -> bool
	Checks if unary predicate p returns true for all elements in the range [first, last).
template<typename InputIt, typename Predicate>
constexpr auto	any_of (InputIt first, InputIt last, Predicate p) -> bool
	Checks if unary predicate p returns true for at least one element in the range [first, last).
template<typename ForwardIt, typename T, typename Compare>
constexpr auto	binary_search (ForwardIt first, ForwardIt last, T const &value, Compare comp) -> bool
	Checks if an element equivalent to value appears within the range [first, last). For binary_search to succeed, the range [first, last) must be at least partially ordered with respect to value.
template<typename ForwardIt, typename T>
constexpr auto	binary_search (ForwardIt first, ForwardIt last, T const &value) -> bool
	Checks if an element equivalent to value appears within the range [first, last). For binary_search to succeed, the range [first, last) must be at least partially ordered with respect to value.
template<typename RandomIt, typename Compare>
constexpr auto	bubble_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.
template<typename RandomIt>
constexpr auto	bubble_sort (RandomIt first, RandomIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.
template<typename Type, typename Compare>
constexpr auto	clamp (Type const &v, Type const &lo, Type const &hi, Compare comp) -> Type const &
	If v compares less than lo, returns lo; otherwise if hi compares less than v, returns hi; otherwise returns v. Uses operator< to compare the values.
template<typename Type>
constexpr auto	clamp (Type const &v, Type const &lo, Type const &hi) noexcept -> Type const &
	If v compares less than lo, returns lo; otherwise if hi compares less than v, returns hi; otherwise returns v. Uses operator< to compare the values.
template<typename BidirIt, typename Compare>
constexpr auto	merge_sort (BidirIt first, BidirIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename BidirIt>
constexpr auto	merge_sort (BidirIt first, BidirIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename FwdIt1, typename FwdIt2, typename Predicate>
constexpr auto	search (FwdIt1 first, FwdIt1 last, FwdIt2 sFirst, FwdIt2 sLast, Predicate pred) -> FwdIt1
	Searches for the first occurrence of the sequence of elements [sFirst, sLast) in the range [first, last).
template<typename FwdIt1, typename FwdIt2>
constexpr auto	search (FwdIt1 first, FwdIt1 last, FwdIt2 sFirst, FwdIt2 sLast) -> FwdIt1
	Searches for the first occurrence of the sequence of elements [sFirst, sLast) in the range [first, last).
template<typename FwdIt, typename Searcher>
constexpr auto	search (FwdIt first, FwdIt last, Searcher const &searcher) -> FwdIt
	Searches for the first occurrence of the sequence of elements [sFirst, sLast) in the range [first, last).
template<typename ForwardIt, typename Size, typename ValueT, typename Predicate>
constexpr auto	search_n (ForwardIt first, ForwardIt last, Size count, ValueT const &value, Predicate pred) -> ForwardIt
	Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value.
template<typename ForwardIt, typename Size, typename ValueT>
constexpr auto	search_n (ForwardIt first, ForwardIt last, Size count, ValueT const &value) -> ForwardIt
	Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value.
template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>
constexpr auto	set_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at destination. Elements are compared using the given binary comparison function comp and the ranges must be sorted with respect to the same.
template<typename InputIt1, typename InputIt2, typename OutputIt>
constexpr auto	set_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination) -> OutputIt
	Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at destination. Elements are compared using the given binary comparison function comp and the ranges must be sorted with respect to the same.
template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>
constexpr auto	set_intersection (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest, Compare comp) -> OutputIt
	Constructs a sorted range beginning at dest consisting of elements that are found in both sorted ranges [first1, last1) and [first2, last2). If some element is found m times in [first1, last1) and n times in [first2, last2), the first min(m, n) elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.
template<typename InputIt1, typename InputIt2, typename OutputIt>
constexpr auto	set_intersection (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest) -> OutputIt
	Constructs a sorted range beginning at dest consisting of elements that are found in both sorted ranges [first1, last1) and [first2, last2). If some element is found m times in [first1, last1) and n times in [first2, last2), the first min(m, n) elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.
template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>
constexpr auto	set_symmetric_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Computes symmetric difference of two sorted ranges: the elements that are found in either of the ranges, but not in both of them are copied to the range beginning at destination. The resulting range is also sorted.
template<typename InputIt1, typename InputIt2, typename OutputIt>
constexpr auto	set_symmetric_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest) -> OutputIt
	Computes symmetric difference of two sorted ranges: the elements that are found in either of the ranges, but not in both of them are copied to the range beginning at destination. The resulting range is also sorted.
template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>
constexpr auto	set_union (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Constructs a sorted union beginning at destination consisting of the set of elements present in one or both sorted ranges [first1, last1) and [first2, last2). The resulting range cannot overlap with either of the input ranges.
template<typename InputIt1, typename InputIt2, typename OutputIt>
constexpr auto	set_union (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination) -> OutputIt
	Constructs a sorted union beginning at destination consisting of the set of elements present in one or both sorted ranges [first1, last1) and [first2, last2). The resulting range cannot overlap with either of the input ranges.
template<typename RandomIt, typename Compare>
constexpr auto	sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is not guaranteed to be preserved.
template<typename RandomIt>
constexpr auto	sort (RandomIt first, RandomIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is not guaranteed to be preserved.
template<typename RandomIt, typename Compare>
constexpr auto	stable_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equivalent elements is guaranteed to be preserved. Elements are compared using the given comparison function comp.
template<typename RandomIt>
constexpr auto	stable_sort (RandomIt first, RandomIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equivalent elements is guaranteed to be preserved. Elements are compared using the given comparison function comp.
template<typename InputIt, typename OutputIt, typename UnaryOp>
constexpr auto	transform (InputIt first, InputIt last, OutputIt dest, UnaryOp op) -> OutputIt
	Applies the given function to a range and stores the result in another range, beginning at dest. The unary operation op is applied to the range defined by [first, last).
template<typename InputIt1, typename InputIt2, typename OutputIt, typename BinaryOp>
constexpr auto	transform (InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt dest, BinaryOp op) -> OutputIt
	Applies the given function to a range and stores the result in another range, beginning at dest. The unary operation op is applied to the range defined by [first, last).
template<typename ForwardIt, typename Predicate>
constexpr auto	unique (ForwardIt first, ForwardIt last, Predicate pred) -> ForwardIt
	Eliminates all except the first element from every consecutive group of equivalent elements from the range [first, last) and returns a past-the-end iterator for the new logical end of the range.
template<typename ForwardIt>
constexpr auto	unique (ForwardIt first, ForwardIt last) -> ForwardIt
	Eliminates all except the first element from every consecutive group of equivalent elements from the range [first, last) and returns a past-the-end iterator for the new logical end of the range.
template<typename InputIt, typename OutputIt, typename Predicate>
constexpr auto	unique_copy (InputIt first, InputIt last, OutputIt destination, Predicate pred) -> OutputIt
	Copies the elements from the range [first, last), to another range beginning at d_first in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied.
template<typename InputIt, typename OutputIt>
constexpr auto	unique_copy (InputIt first, InputIt last, OutputIt destination) -> OutputIt
	Copies the elements from the range [first, last), to another range beginning at d_first in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied.
template<typename ForwardIt, typename T, typename Compare>
constexpr auto	upper_bound (ForwardIt first, ForwardIt last, T const &value, Compare comp) -> ForwardIt
	Returns an iterator pointing to the first element in the range [first, last) that is greater than value, or last if no such element is found.
template<typename ForwardIt, typename T>
constexpr auto	upper_bound (ForwardIt first, ForwardIt last, T const &value) -> ForwardIt
	Returns an iterator pointing to the first element in the range [first, last) that is greater than value, or last if no such element is found.

Detailed Description

Algorithms that operate on ranges.

Function Documentation

adjacent_find() [1/2]

template<typename ForwardIt>

auto adjacent_find ( ForwardIt first, ForwardIt last ) -> ForwardIt

nodiscardconstexpr

Searches the range [first, last) for two consecutive equal elements. Elements are compared using the given binary predicate p.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
pred	Binary predicate which returns ​true if the elements should be treated as equal.

https://en.cppreference.com/w/cpp/algorithm/adjacent_find

adjacent_find() [2/2]

template<typename ForwardIt, typename Predicate>

auto adjacent_find ( ForwardIt first, ForwardIt last, Predicate pred ) -> ForwardIt

nodiscardconstexpr

Searches the range [first, last) for two consecutive equal elements. Elements are compared using the given binary predicate p.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
pred	Binary predicate which returns ​true if the elements should be treated as equal.

https://en.cppreference.com/w/cpp/algorithm/adjacent_find

all_of()

template<typename InputIt, typename Predicate>

auto all_of ( InputIt first, InputIt last, Predicate p ) -> bool

nodiscardconstexpr

Checks if unary predicate p returns true for all elements in the range [first, last).

Examples

array.cpp.

any_of()

template<typename InputIt, typename Predicate>

auto any_of ( InputIt first, InputIt last, Predicate p ) -> bool

nodiscardconstexpr

Checks if unary predicate p returns true for at least one element in the range [first, last).

binary_search() [1/2]

template<typename ForwardIt, typename T>

auto binary_search ( ForwardIt first, ForwardIt last, T const & value ) -> bool

nodiscardconstexpr

Checks if an element equivalent to value appears within the range [first, last). For binary_search to succeed, the range [first, last) must be at least partially ordered with respect to value.

https://en.cppreference.com/w/cpp/algorithm/binary_search

binary_search() [2/2]

template<typename ForwardIt, typename T, typename Compare>

auto binary_search ( ForwardIt first, ForwardIt last, T const & value, Compare comp ) -> bool

nodiscardconstexpr

Checks if an element equivalent to value appears within the range [first, last). For binary_search to succeed, the range [first, last) must be at least partially ordered with respect to value.

https://en.cppreference.com/w/cpp/algorithm/binary_search

bubble_sort() [1/2]

template<typename RandomIt>

auto bubble_sort ( RandomIt first, RandomIt last ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.

https://en.wikipedia.org/wiki/Bubble_sort

Note

Non-standard extension

bubble_sort() [2/2]

template<typename RandomIt, typename Compare>

auto bubble_sort ( RandomIt first, RandomIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.

https://en.wikipedia.org/wiki/Bubble_sort

Note

Non-standard extension

clamp() [1/2]

template<typename Type>

auto clamp ( Type const & v, Type const & lo, Type const & hi ) -> Type const&

nodiscardconstexprnoexcept

If v compares less than lo, returns lo; otherwise if hi compares less than v, returns hi; otherwise returns v. Uses operator< to compare the values.

clamp() [2/2]

template<typename Type, typename Compare>

auto clamp ( Type const & v, Type const & lo, Type const & hi, Compare comp ) -> Type const&

nodiscardconstexpr

If v compares less than lo, returns lo; otherwise if hi compares less than v, returns hi; otherwise returns v. Uses operator< to compare the values.

copy()

template<typename InputIt, typename OutputIt>

auto copy ( InputIt first, InputIt last, OutputIt destination ) -> OutputIt

constexpr

Copies the elements in the range, defined by [first, last), to another range beginning at destination.

Copies all elements in the range [first, last) starting from first and proceeding to last - 1. The behavior is undefined if destination is within the range [first, last). In this case, copy_backward may be used instead.

Returns

Output iterator to the element in the destination range, one past the last element copied.

Examples

array.cpp.

copy_backward()

template<typename BidirIt1, typename BidirIt2>

auto copy_backward ( BidirIt1 first, BidirIt1 last, BidirIt2 dLast ) -> BidirIt2

constexpr

Copies the elements from the range, defined by [first, last), to another range ending at dLast. The elements are copied in reverse order (the last element is copied first), but their relative order is preserved.

The behavior is undefined if dLast is within (first, last]. copy must be used instead of copy_backward in that case.

Returns

Iterator to the last element copied.

copy_if()

template<typename InIt, typename OutIt, typename Pred>

auto copy_if ( InIt first, InIt last, OutIt dFirst, Pred pred ) -> OutIt

constexpr

Copies the elements in the range, defined by [first, last), to another range beginning at destination.

Only copies the elements for which the predicate pred returns true. The relative order of the elements that are copied is preserved. The behavior is undefined if the source and the destination ranges overlap.

Returns

Output iterator to the element in the destination range, one past the last element copied.

copy_n()

template<typename InputIt, typename Size, typename OutputIt>

auto copy_n ( InputIt first, Size count, OutputIt result ) -> OutputIt

constexpr

Copies exactly count values from the range beginning at first to the range beginning at result. Formally, for each integer 0 <= i < count, performs *(result + i) = *(first + i). Overlap of ranges is formally permitted, but leads to unpredictable ordering of the results.

Returns

Iterator in the destination range, pointing past the last element copied if count>0 or result otherwise.

count()

template<typename InputIt, typename T>

auto count ( InputIt first, InputIt last, T const & value ) -> typename iterator_traits<InputIt>::difference_type

nodiscardconstexpr

Returns the number of elements in the range [first, last) satisfying specific criteria. Counts the elements that are equal to value.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
value	The value to search for.

https://en.cppreference.com/w/cpp/algorithm/count

count_if()

template<typename InputIt, typename Predicate>

auto count_if ( InputIt first, InputIt last, Predicate p ) -> typename iterator_traits<InputIt>::difference_type

nodiscardconstexpr

Returns the number of elements in the range [first, last) satisfying specific criteria. Counts elements for which predicate p returns true.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
p	Unary predicate which returns ​true for the required elements.

https://en.cppreference.com/w/cpp/algorithm/count

equal() [1/4]

template<typename InputIt1, typename InputIt2>

auto equal ( InputIt1 first1, InputIt1 last1, InputIt2 first2 ) -> bool

nodiscardconstexpr

equal() [2/4]

template<typename InputIt1, typename InputIt2>

auto equal ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 ) -> bool

nodiscardconstexpr

equal() [3/4]

template<typename InputIt1, typename InputIt2, typename Predicate>

auto equal ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Predicate p ) -> bool

nodiscardconstexpr

equal() [4/4]

template<typename InputIt1, typename InputIt2, typename Predicate>

auto equal ( InputIt1 first1, InputIt1 last1, InputIt2 first2, Predicate p ) -> bool

nodiscardconstexpr

Returns true if the range [first1, last1) is equal to the range [first2, first2 + (last1 - first1)), and false otherwise.

equal_range() [1/2]

template<typename ForwardIt, typename T>

auto equal_range ( ForwardIt first, ForwardIt last, T const & value ) -> pair<ForwardIt, ForwardIt>

nodiscardconstexpr

equal_range() [2/2]

template<typename ForwardIt, typename T, typename Compare>

auto equal_range ( ForwardIt first, ForwardIt last, T const & value, Compare comp ) -> pair<ForwardIt, ForwardIt>

nodiscardconstexpr

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

https://en.cppreference.com/w/cpp/algorithm/equal_range

exchange_sort() [1/2]

template<typename RandomIt>

auto exchange_sort ( RandomIt first, RandomIt last ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order.

https://en.wikipedia.org/wiki/Sorting_algorithm#Exchange_sort

Note

Non-standard extension

exchange_sort() [2/2]

template<typename RandomIt, typename Compare>

auto exchange_sort ( RandomIt first, RandomIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order.

https://en.wikipedia.org/wiki/Sorting_algorithm#Exchange_sort

Note

Non-standard extension

fill()

template<typename ForwardIt, typename T>

auto fill ( ForwardIt first, ForwardIt last, T const & value ) -> void

constexpr

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

fill_n()

template<typename OutputIt, typename Size, typename T>

auto fill_n ( OutputIt first, Size count, T const & value ) -> OutputIt

constexpr

Assigns the given value to the first count elements in the range beginning at first if count > 0. Does nothing otherwise.

Returns

Iterator one past the last element assigned if count > 0, first otherwise.

find()

template<typename InputIt, typename T>

auto find ( InputIt first, InputIt last, T const & value ) -> InputIt

nodiscardconstexprnoexcept

Searches for an element equal to value.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
value	Value to compare the elements to.

https://en.cppreference.com/w/cpp/algorithm/find

Examples

algorithm.cpp.

find_end() [1/2]

template<typename ForwardIt1, typename ForwardIt2>

auto find_end ( ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast ) -> ForwardIt1

nodiscardconstexpr

find_end() [2/2]

template<typename ForwardIt1, typename ForwardIt2, typename Predicate>

auto find_end ( ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast, Predicate p ) -> ForwardIt1

nodiscardconstexpr

Searches for the last occurrence of the sequence [sFirst, sLast) in the range [first, last). Elements are compared using the given binary predicate p.

Parameters

first	The range of elements to examine
last	The range of elements to examine
sFirst	The range of elements to search for
sLast	The range of elements to search for
p	Binary predicate

Returns

Iterator to the beginning of last occurrence of the sequence [sFirst, sLast) in range [first, last). If [sFirst, sLast) is empty or if no such sequence is found, last is returned.

find_first_of() [1/2]

template<typename InputIt, typename ForwardIt>

auto find_first_of ( InputIt first, InputIt last, ForwardIt sFirst, ForwardIt sLast ) -> InputIt

nodiscardconstexpr

Searches the range [first, last) for any of the elements in the range [sFirst, sLast).

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
sFirst	The range of elements to search for.
sLast	The range of elements to search for.

https://en.cppreference.com/w/cpp/algorithm/find_first_of

find_first_of() [2/2]

template<typename InputIt, typename ForwardIt, typename Predicate>

auto find_first_of ( InputIt first, InputIt last, ForwardIt sFirst, ForwardIt sLast, Predicate pred ) -> InputIt

nodiscardconstexpr

Searches the range [first, last) for any of the elements in the range [sFirst, sLast). Elements are compared using the given binary predicate pred.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
sFirst	The range of elements to search for.
sLast	The range of elements to search for.
pred	Predicate which returns ​true if the elements should be treated as equal.

https://en.cppreference.com/w/cpp/algorithm/find_first_of

find_if()

template<typename InputIt, typename Predicate>

auto find_if ( InputIt first, InputIt last, Predicate pred ) -> InputIt

nodiscardconstexprnoexcept

Searches for an element for which predicate p returns true.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
pred	Unary predicate which returns ​true for the required element.

https://en.cppreference.com/w/cpp/algorithm/find

find_if_not()

template<typename InputIt, typename Predicate>

auto find_if_not ( InputIt first, InputIt last, Predicate pred ) -> InputIt

nodiscardconstexprnoexcept

Searches for an element for which predicate q returns false.

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
pred	Unary predicate which returns ​true for the required element.

https://en.cppreference.com/w/cpp/algorithm/find

for_each()

template<typename InputIt, typename UnaryFunc>

auto for_each ( InputIt first, InputIt last, UnaryFunc f ) -> UnaryFunc

constexprnoexcept

Applies the given function object f to the result of dereferencing every iterator in the range [first, last) in order.

Parameters

first	The range to apply the function to.
last	The range to apply the function to.
f	Function object, to be applied to the result of dereferencing every iterator in the range.

https://en.cppreference.com/w/cpp/algorithm/for_each

Examples

set.cpp.

for_each_n()

template<typename InputIt, typename Size, typename UnaryFunc>

auto for_each_n ( InputIt first, Size n, UnaryFunc f ) -> InputIt

constexprnoexcept

Applies the given function object f to the result of dereferencing every iterator in the range [first, first + n] in order.

Parameters

first	The beginning of the range to apply the function to.
n	The number of elements to apply the function to.
f	Function object, to be applied to the result of dereferencing every iterator in the range.

https://en.cppreference.com/w/cpp/algorithm/for_each_n

generate()

template<typename ForwardIt, typename Generator>

auto generate ( ForwardIt first, ForwardIt last, Generator g ) -> void

constexpr

Assigns each element in range [first, last) a value generated by the given function object g.

Parameters

first	The range of elements to generate.
last	The range of elements to generate.
g	Generator function object that will be called.

https://en.cppreference.com/w/cpp/algorithm/generate

generate_n()

template<typename OutputIt, typename SizeT, typename Generator>

auto generate_n ( OutputIt first, SizeT count, Generator g ) -> OutputIt

constexpr

Assigns values, generated by given function object g, to the first count elements in the range beginning at first, if count > 0. Does nothing otherwise.

Parameters

first	The range of elements to generate.
count	Number of the elements to generate.
g	Generator function object that will be called.

https://en.cppreference.com/w/cpp/algorithm/generate_n

gnome_sort() [1/2]

template<typename BidirIt>

auto gnome_sort ( BidirIt first, BidirIt last ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order.

https://en.wikipedia.org/wiki/Gnome_sort

Note

Non-standard extension

gnome_sort() [2/2]

template<typename BidirIt, typename Compare>

auto gnome_sort ( BidirIt first, BidirIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order.

https://en.wikipedia.org/wiki/Gnome_sort

Note

Non-standard extension

includes() [1/2]

template<typename InputIt1, typename InputIt2>

auto includes ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 ) -> bool

nodiscardconstexpr

includes() [2/2]

template<typename InputIt1, typename InputIt2, typename Compare>

auto includes ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp ) -> bool

nodiscardconstexpr

Returns true if the sorted range [first2, last2) is a subsequence of the sorted range [first1, last1). Both ranges must be sorted.

inplace_merge() [1/2]

template<typename BidirIt, typename Compare>

auto inplace_merge ( BidirIt begin, BidirIt mid, BidirIt end, Compare comp ) -> void

constexpr

Merges two consecutive sorted ranges [first, middle) and [middle, last) into one sorted range [first, last).

A sequence [first, last) is said to be sorted with respect to a comparator comp if for any iterator it pointing to the sequence and any non-negative integer n such that it + n is a valid iterator pointing to an element of the sequence, comp(*(it + n), *it) evaluates to false.

https://en.cppreference.com/w/cpp/algorithm/inplace_merge

inplace_merge() [2/2]

template<typename BidirIt>

auto inplace_merge ( BidirIt first, BidirIt mid, BidirIt last ) -> void

constexpr

insertion_sort() [1/2]

template<typename RandomIt>

auto insertion_sort ( RandomIt first, RandomIt last ) -> void

constexpr

Note

Non-standard extension

insertion_sort() [2/2]

template<typename RandomIt, typename Compare>

auto insertion_sort ( RandomIt first, RandomIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.

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

Note

Non-standard extension

is_partitioned()

template<typename InputIt, typename Predicate>

auto is_partitioned ( InputIt first, InputIt last, Predicate p ) -> bool

nodiscardconstexpr

Returns true if all elements in the range [first, last) that satisfy the predicate p appear before all elements that don't. Also returns true if the range is empty.

https://en.cppreference.com/w/cpp/algorithm/is_partitioned

is_permutation() [1/2]

template<typename ForwardIt1, typename ForwardIt2>

auto is_permutation ( ForwardIt1 first, ForwardIt1 last, ForwardIt2 first2 ) -> bool

nodiscardconstexpr

Returns true if there exists a permutation of the elements in the range [first1, last1) that makes that range equal to the range [first2, last2), where last2 denotes first2 + (last1 - first1) if it was not given.

is_permutation() [2/2]

template<typename ForwardIt1, typename ForwardIt2>

auto is_permutation ( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2 ) -> bool

nodiscardconstexpr

is_sorted() [1/2]

template<typename ForwardIt>

auto is_sorted ( ForwardIt first, ForwardIt last ) -> bool

nodiscardconstexpr

Checks if the elements in range [first, last) are sorted in non-descending order.

is_sorted() [2/2]

template<typename ForwardIt, typename Compare>

auto is_sorted ( ForwardIt first, ForwardIt last, Compare comp ) -> bool

nodiscardconstexpr

is_sorted_until() [1/2]

template<typename ForwardIt>

auto is_sorted_until ( ForwardIt first, ForwardIt last ) -> ForwardIt

nodiscardconstexpr

Examines the range [first, last) and finds the largest range beginning at first in which the elements are sorted in non-descending order.

is_sorted_until() [2/2]

template<typename ForwardIt, typename Compare>

auto is_sorted_until ( ForwardIt first, ForwardIt last, Compare comp ) -> ForwardIt

nodiscardconstexpr

iter_swap()

template<typename ForwardIt1, typename ForwardIt2>

auto iter_swap ( ForwardIt1 a, ForwardIt2 b ) -> void

constexpr

Swaps the values of the elements the given iterators are pointing to.

Parameters

a	Iterators to the elements to swap.
b	Iterators to the elements to swap.

https://en.cppreference.com/w/cpp/algorithm/iter_swap

lexicographical_compare() [1/2]

template<typename InputIt1, typename InputIt2>

auto lexicographical_compare ( InputIt1 f1, InputIt1 l1, InputIt2 f2, InputIt2 l2 ) -> bool

nodiscardconstexpr

lexicographical_compare() [2/2]

template<typename InputIt1, typename InputIt2, typename Compare>

auto lexicographical_compare ( InputIt1 f1, InputIt1 l1, InputIt2 f2, InputIt2 l2, Compare comp ) -> bool

nodiscardconstexpr

Checks if the first range [f1, l1) is lexicographically less than the second range [f2, l2).

https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare

lower_bound() [1/2]

template<typename ForwardIt, typename T>

auto lower_bound ( ForwardIt first, ForwardIt last, T const & value ) -> ForwardIt

nodiscardconstexprnoexcept

lower_bound() [2/2]

template<typename ForwardIt, typename T, typename Compare>

auto lower_bound ( ForwardIt first, ForwardIt last, T const & value, Compare comp ) -> ForwardIt

nodiscardconstexprnoexcept

Returns an iterator pointing to the first element in the range [first, last) that is not less than (i.e. greater or equal to) value, or last if no such element is found.

https://en.cppreference.com/w/cpp/algorithm/lower_bound

max() [1/2]

template<typename Type>

auto max ( Type const & a, Type const & b ) -> Type const&

nodiscardconstexprnoexcept

Returns the greater of a and b.

max() [2/2]

template<typename Type, typename Compare>

auto max ( Type const & a, Type const & b, Compare comp ) -> Type const&

nodiscardconstexprnoexcept

Returns the greater of a and b, using a compare function.

max_element() [1/2]

template<typename ForwardIt>

auto max_element ( ForwardIt first, ForwardIt last ) -> ForwardIt

nodiscardconstexprnoexcept

Finds the greatest element in the range [first, last). Elements are compared using operator<.

max_element() [2/2]

template<typename ForwardIt, typename Compare>

auto max_element ( ForwardIt first, ForwardIt last, Compare comp ) -> ForwardIt

nodiscardconstexpr

Finds the greatest element in the range [first, last). Elements are compared using the given binary comparison function comp.

merge() [1/2]

template<typename InputIt1, typename InputIt2, typename OutputIt>

auto merge ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination ) -> OutputIt

constexpr

merge() [2/2]

template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>

auto merge ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp ) -> OutputIt

constexpr

Merges two sorted ranges [first1, last1) and [first2, last2) into one sorted range beginning at destination.

merge_sort() [1/2]

template<typename BidirIt>

auto merge_sort ( BidirIt first, BidirIt last ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order.

https://en.wikipedia.org/wiki/Merge_sort

Note

Non-standard extension

merge_sort() [2/2]

template<typename BidirIt, typename Compare>

auto merge_sort ( BidirIt first, BidirIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order.

https://en.wikipedia.org/wiki/Merge_sort

Note

Non-standard extension

min() [1/2]

template<typename Type>

auto min ( Type const & a, Type const & b ) -> Type const&

nodiscardconstexprnoexcept

Returns the smaller of a and b.

min() [2/2]

template<typename Type, typename Compare>

auto min ( Type const & a, Type const & b, Compare comp ) -> Type const&

nodiscardconstexprnoexcept

Returns the smaller of a and b, using a compare function.

min_element() [1/2]

template<typename ForwardIt>

auto min_element ( ForwardIt first, ForwardIt last ) -> ForwardIt

nodiscardconstexprnoexcept

Finds the smallest element in the range [first, last). Elements are compared using operator<.

min_element() [2/2]

template<typename ForwardIt, typename Compare>

auto min_element ( ForwardIt first, ForwardIt last, Compare comp ) -> ForwardIt

nodiscardconstexpr

Finds the smallest element in the range [first, last). Elements are compared using the given binary comparison function comp.

minmax() [1/2]

template<typename T>

auto minmax ( T const & a, T const & b ) -> pair<T const&, T const&>

nodiscardconstexpr

Returns the lowest and the greatest of the given values.

minmax() [2/2]

template<typename T, typename Compare>

auto minmax ( T const & a, T const & b, Compare comp ) -> pair<T const&, T const&>

nodiscardconstexpr

Returns the lowest and the greatest of the given values.

minmax_element() [1/2]

template<typename ForwardIt>

auto minmax_element ( ForwardIt first, ForwardIt last ) -> pair<ForwardIt, ForwardIt>

nodiscardconstexpr

Finds the smallest and greatest element in the range [first, last).

minmax_element() [2/2]

template<typename ForwardIt, typename Compare>

auto minmax_element ( ForwardIt first, ForwardIt last, Compare comp ) -> pair<ForwardIt, ForwardIt>

nodiscardconstexpr

Finds the smallest and greatest element in the range [first, last).

mismatch()

template<typename InputIt1, typename InputIt2, typename Predicate>

auto mismatch ( InputIt1 first1, InputIt1 last1, InputIt2 first2, Predicate pred ) -> pair<InputIt1, InputIt2>

nodiscardconstexpr

Returns the first mismatching pair of elements from two ranges: one defined by [first1, last1) and another defined by [first2,last2). If last2 is not provided (overloads (1-4)), it denotes first2 + (last1 - first1). Elements are compared using the given binary predicate pred.

Parameters

first1	The first range of the elements.
last1	The first range of the elements.
first2	The second range of the elements.
pred	Binary predicate which returns ​true if the elements should be treated as equal.

https://en.cppreference.com/w/cpp/algorithm/mismatch

move()

template<typename InputIt, typename OutputIt>

auto move ( InputIt first, InputIt last, OutputIt destination ) -> OutputIt

constexpr

Moves the elements in the range [first, last), to another range beginning at destination, starting from first and proceeding to last - 1. After this operation the elements in the moved-from range will still contain valid values of the appropriate type, but not necessarily the same values as before the move.

https://en.cppreference.com/w/cpp/algorithm/move

Returns

Output iterator to the element past the last element moved.

Parameters

first	The range of elements to move.
last	The range of elements to move.
destination	The beginning of the destination range.

Examples

optional.cpp.

move_backward()

template<typename BidirIt1, typename BidirIt2>

auto move_backward ( BidirIt1 first, BidirIt1 last, BidirIt2 destination ) -> BidirIt2

constexpr

Moves the elements from the range [first, last), to another range ending at destination. The elements are moved in reverse order (the last element is moved first), but their relative order is preserved.

https://en.cppreference.com/w/cpp/algorithm/move_backward

Returns

Iterator in the destination range, pointing at the last element moved.

Parameters

first	The range of elements to move.
last	The range of elements to move.
destination	End of the destination range.

none_of()

template<typename InputIt, typename Predicate>

auto none_of ( InputIt first, InputIt last, Predicate p ) -> bool

nodiscardconstexpr

Checks if unary predicate p returns true for no elements in the range [first, last).

nth_element()

template<typename RandomIt, typename Compare>

auto nth_element ( RandomIt first, RandomIt nth, RandomIt last, Compare comp ) -> void

constexpr

nth_element is a partial sorting algorithm that rearranges elements in [first, last) such that:

• The element pointed at by nth is changed to whatever element would occur in that position if [first, last) were sorted.
• All of the elements before this new nth element are less than or equal to the elements after the new nth element.

https://en.cppreference.com/w/cpp/algorithm/nth_element

partial_sort()

template<typename RandomIt, typename Compare>

auto partial_sort ( RandomIt first, RandomIt middle, RandomIt last, Compare comp ) -> void

constexpr

Rearranges elements such that the range [first, middle) contains the sorted middle - first smallest elements in the range [first, last). The order of equal elements is not guaranteed to be preserved. The order of the remaining elements in the range [middle, last) is unspecified.

https://en.cppreference.com/w/cpp/algorithm/partial_sort

partition()

template<typename ForwardIt, typename Predicate>

auto partition ( ForwardIt first, ForwardIt last, Predicate p ) -> ForwardIt

constexpr

Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is not preserved.

partition_copy()

template<typename InputIt, typename OutputIt1, typename OutputIt2, typename Predicate>

auto partition_copy ( InputIt first, InputIt last, OutputIt1 destinationTrue, OutputIt2 destinationFalse, Predicate p ) -> pair<OutputIt1, OutputIt2>

constexpr

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

The behavior is undefined if the input range overlaps either of the output ranges.

partition_point()

template<typename ForwardIt, typename Predicate>

auto partition_point ( ForwardIt first, ForwardIt last, Predicate p ) -> ForwardIt

nodiscardconstexpr

Examines the partitioned (as if by partition) range [first, last) and locates the end of the first partition, that is, the first element that does not satisfy p or last if all elements satisfy p.

remove()

template<typename ForwardIt, typename T>

auto remove ( ForwardIt first, ForwardIt last, T const & value ) -> ForwardIt

nodiscardconstexpr

Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.

remove_copy()

template<typename InputIt, typename OutputIt, typename T>

auto remove_copy ( InputIt first, InputIt last, OutputIt destination, T const & value ) -> OutputIt

constexpr

Copies elements from the range [first, last), to another range beginning at destination, omitting the elements which satisfy specific criteria. Source and destination ranges cannot overlap. Ignores all elements that are equal to value.

Returns

Iterator to the element past the last element copied.

remove_copy_if()

template<typename InputIt, typename OutputIt, typename Predicate>

auto remove_copy_if ( InputIt first, InputIt last, OutputIt destination, Predicate p ) -> OutputIt

constexpr

Copies elements from the range [first, last), to another range beginning at destination, omitting the elements which satisfy specific criteria. Source and destination ranges cannot overlap. Ignores all elements for which predicate p returns true.

Returns

Iterator to the element past the last element copied.

remove_if()

template<typename ForwardIt, typename Predicate>

auto remove_if ( ForwardIt first, ForwardIt last, Predicate pred ) -> ForwardIt

nodiscardconstexpr

Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.

replace()

template<typename ForwardIt, typename T>

auto replace ( ForwardIt first, ForwardIt last, T const & oldValue, T const & newValue ) -> void

constexpr

Replaces all elements satisfying specific criteria with new_value in the range [first, last). Replaces all elements that are equal to old_value.

replace_if()

template<typename ForwardIt, typename Predicate, typename T>

auto replace_if ( ForwardIt first, ForwardIt last, Predicate p, T const & newValue ) -> void

constexpr

Replaces all elements satisfying specific criteria with new_value in the range [first, last). Replaces all elements for which predicate p returns true.

reverse()

template<typename BidirIt>

auto reverse ( BidirIt first, BidirIt last ) -> void

constexpr

Reverses the order of the elements in the range [first, last).

reverse_copy()

template<typename BidirIt, typename OutputIt>

auto reverse_copy ( BidirIt first, BidirIt last, OutputIt destination ) -> OutputIt

constexpr

Copies the elements from the range [first, last) to another range beginning at d_first in such a way that the elements in the new range are in reverse order.

If the source and destination ranges (that is, [first, last) and [d_first, d_first+(last-first)) respectively) overlap, the behavior is undefined.

rotate()

template<typename ForwardIt>

auto rotate ( ForwardIt first, ForwardIt nFirst, ForwardIt last ) -> ForwardIt

constexpr

Performs a left rotation on a range of elements.

Specifically, rotate swaps the elements in the range [first, last) in such a way that the element n_first becomes the first element of the new range and n_first - 1 becomes the last element. A precondition of this function is that [first, n_first) and [n_first, last) are valid ranges.

rotate_copy()

template<typename ForwardIt, typename OutputIt>

auto rotate_copy ( ForwardIt first, ForwardIt nFirst, ForwardIt last, OutputIt destination ) -> OutputIt

constexpr

Copies the elements from the range [first, last), to another range beginning at destination in such a way, that the element nFirst becomes the first element of the new range and nFirst - 1 becomes the last element.

search() [1/3]

template<typename FwdIt, typename Searcher>

auto search ( FwdIt first, FwdIt last, Searcher const & searcher ) -> FwdIt

nodiscardconstexpr

Searches for the first occurrence of the sequence of elements [sFirst, sLast) in the range [first, last).

https://en.cppreference.com/w/cpp/algorithm/search

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
sFirst	The range of elements to search for.
sLast	The range of elements to search for.
pred	Binary predicate which returns ​true if the elements should be treated as equal.

search() [2/3]

template<typename FwdIt1, typename FwdIt2>

auto search ( FwdIt1 first, FwdIt1 last, FwdIt2 sFirst, FwdIt2 sLast ) -> FwdIt1

nodiscardconstexpr

Searches for the first occurrence of the sequence of elements [sFirst, sLast) in the range [first, last).

https://en.cppreference.com/w/cpp/algorithm/search

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
sFirst	The range of elements to search for.
sLast	The range of elements to search for.
pred	Binary predicate which returns ​true if the elements should be treated as equal.

search() [3/3]

template<typename FwdIt1, typename FwdIt2, typename Predicate>

auto search ( FwdIt1 first, FwdIt1 last, FwdIt2 sFirst, FwdIt2 sLast, Predicate pred ) -> FwdIt1

nodiscardconstexpr

Searches for the first occurrence of the sequence of elements [sFirst, sLast) in the range [first, last).

https://en.cppreference.com/w/cpp/algorithm/search

Parameters

first	The range of elements to examine.
last	The range of elements to examine.
sFirst	The range of elements to search for.
sLast	The range of elements to search for.
pred	Binary predicate which returns ​true if the elements should be treated as equal.

search_n() [1/2]

template<typename ForwardIt, typename Size, typename ValueT>

auto search_n ( ForwardIt first, ForwardIt last, Size count, ValueT const & value ) -> ForwardIt

nodiscardconstexpr

Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value.

search_n() [2/2]

template<typename ForwardIt, typename Size, typename ValueT, typename Predicate>

auto search_n ( ForwardIt first, ForwardIt last, Size count, ValueT const & value, Predicate pred ) -> ForwardIt

nodiscardconstexpr

Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value.

set_difference() [1/2]

template<typename InputIt1, typename InputIt2, typename OutputIt>

auto set_difference ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination ) -> OutputIt

constexpr

Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at destination. Elements are compared using the given binary comparison function comp and the ranges must be sorted with respect to the same.

set_difference() [2/2]

template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>

auto set_difference ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp ) -> OutputIt

constexpr

Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at destination. Elements are compared using the given binary comparison function comp and the ranges must be sorted with respect to the same.

set_intersection() [1/2]

template<typename InputIt1, typename InputIt2, typename OutputIt>

auto set_intersection ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest ) -> OutputIt

constexpr

Constructs a sorted range beginning at dest consisting of elements that are found in both sorted ranges [first1, last1) and [first2, last2). If some element is found m times in [first1, last1) and n times in [first2, last2), the first min(m, n) elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.

set_intersection() [2/2]

template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>

auto set_intersection ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest, Compare comp ) -> OutputIt

constexpr

Constructs a sorted range beginning at dest consisting of elements that are found in both sorted ranges [first1, last1) and [first2, last2). If some element is found m times in [first1, last1) and n times in [first2, last2), the first min(m, n) elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.

set_symmetric_difference() [1/2]

template<typename InputIt1, typename InputIt2, typename OutputIt>

auto set_symmetric_difference ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest ) -> OutputIt

constexpr

Computes symmetric difference of two sorted ranges: the elements that are found in either of the ranges, but not in both of them are copied to the range beginning at destination. The resulting range is also sorted.

set_symmetric_difference() [2/2]

template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>

auto set_symmetric_difference ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp ) -> OutputIt

constexpr

Computes symmetric difference of two sorted ranges: the elements that are found in either of the ranges, but not in both of them are copied to the range beginning at destination. The resulting range is also sorted.

set_union() [1/2]

template<typename InputIt1, typename InputIt2, typename OutputIt>

auto set_union ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination ) -> OutputIt

constexpr

Constructs a sorted union beginning at destination consisting of the set of elements present in one or both sorted ranges [first1, last1) and [first2, last2). The resulting range cannot overlap with either of the input ranges.

set_union() [2/2]

template<typename InputIt1, typename InputIt2, typename OutputIt, typename Compare>

auto set_union ( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp ) -> OutputIt

constexpr

Constructs a sorted union beginning at destination consisting of the set of elements present in one or both sorted ranges [first1, last1) and [first2, last2). The resulting range cannot overlap with either of the input ranges.

shift_left()

template<typename ForwardIt>

auto shift_left ( ForwardIt first, ForwardIt const last, typename iterator_traits< ForwardIt >::difference_type n ) -> ForwardIt

constexpr

Shifts the elements in the range [first, last) by n positions.

Shifts the elements towards the beginning of the range. If n == 0 or n >= last - first, there are no effects. If n < 0, the behavior is undefined. Otherwise, for every integer i in [0, last - first - n), moves the element originally at position first + n + i to position first + i. The moves are performed in increasing order of i starting from ​0​.

shift_right()

template<typename BidiIt>

auto shift_right ( BidiIt first, BidiIt last, typename etl::iterator_traits< BidiIt >::difference_type n ) -> BidiIt

constexpr

Shifts the elements in the range [first, last) by n positions.

Shifts the elements towards the end of the range. If n <= 0 or n >= last - first, there are no effects. Otherwise, for every integer i in [0, last - first - n), moves the element originally at position first + i to position first + n + i.

https://en.cppreference.com/w/cpp/algorithm/shift

Note

The standard specifies that this algorithm should also work with legacy forward iterators. I don't know how to implement that without dynamic memory, so forward iterators are not supported.

sort() [1/2]

template<typename RandomIt>

auto sort ( RandomIt first, RandomIt last ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is not guaranteed to be preserved.

https://en.cppreference.com/w/cpp/algorithm/sort

sort() [2/2]

template<typename RandomIt, typename Compare>

auto sort ( RandomIt first, RandomIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is not guaranteed to be preserved.

https://en.cppreference.com/w/cpp/algorithm/sort

stable_partition()

template<typename BidirIt, typename Predicate>

auto stable_partition ( BidirIt f, BidirIt l, Predicate p ) -> BidirIt

constexpr

Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is preserved.

stable_sort() [1/2]

template<typename RandomIt>

auto stable_sort ( RandomIt first, RandomIt last ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equivalent elements is guaranteed to be preserved. Elements are compared using the given comparison function comp.

https://en.cppreference.com/w/cpp/algorithm/stable_sort

stable_sort() [2/2]

template<typename RandomIt, typename Compare>

auto stable_sort ( RandomIt first, RandomIt last, Compare comp ) -> void

constexpr

Sorts the elements in the range [first, last) in non-descending order. The order of equivalent elements is guaranteed to be preserved. Elements are compared using the given comparison function comp.

https://en.cppreference.com/w/cpp/algorithm/stable_sort

swap_ranges()

template<typename ForwardIt1, typename ForwardIt2>

auto swap_ranges ( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 ) -> ForwardIt2

constexpr

Exchanges elements between range [first1 ,last1) and another range starting at first2.

Parameters

first1	The first range of elements to swap.
last1	The first range of elements to swap.
first2	Beginning of the second range of elements to swap.

Returns

Iterator to the element past the last element exchanged in the range beginning with first2.

https://en.cppreference.com/w/cpp/algorithm/swap_ranges

transform() [1/2]

template<typename InputIt, typename OutputIt, typename UnaryOp>

auto transform ( InputIt first, InputIt last, OutputIt dest, UnaryOp op ) -> OutputIt

constexpr

Applies the given function to a range and stores the result in another range, beginning at dest. The unary operation op is applied to the range defined by [first, last).

https://en.cppreference.com/w/cpp/algorithm/transform

Parameters

first	The first range of elements to transform.
last	The first range of elements to transform.
dest	The beginning of the destination range, may be equal to first.
op	Unary operation function object that will be applied.

Examples

string.cpp, and vector.cpp.

transform() [2/2]

template<typename InputIt1, typename InputIt2, typename OutputIt, typename BinaryOp>

auto transform ( InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt dest, BinaryOp op ) -> OutputIt

constexpr

Applies the given function to a range and stores the result in another range, beginning at dest. The unary operation op is applied to the range defined by [first, last).

https://en.cppreference.com/w/cpp/algorithm/transform

Parameters

first	The first range of elements to transform.
last	The first range of elements to transform.
dest	The beginning of the destination range, may be equal to first.
op	Unary operation function object that will be applied.

unique() [1/2]

template<typename ForwardIt>

auto unique ( ForwardIt first, ForwardIt last ) -> ForwardIt

constexpr

Eliminates all except the first element from every consecutive group of equivalent elements from the range [first, last) and returns a past-the-end iterator for the new logical end of the range.

unique() [2/2]

template<typename ForwardIt, typename Predicate>

auto unique ( ForwardIt first, ForwardIt last, Predicate pred ) -> ForwardIt

constexpr

Eliminates all except the first element from every consecutive group of equivalent elements from the range [first, last) and returns a past-the-end iterator for the new logical end of the range.

unique_copy() [1/2]

template<typename InputIt, typename OutputIt>

auto unique_copy ( InputIt first, InputIt last, OutputIt destination ) -> OutputIt

constexpr

Copies the elements from the range [first, last), to another range beginning at d_first in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied.

Elements are compared using the given binary predicate pred. The behavior is undefined if it is not an equivalence relation.

unique_copy() [2/2]

template<typename InputIt, typename OutputIt, typename Predicate>

auto unique_copy ( InputIt first, InputIt last, OutputIt destination, Predicate pred ) -> OutputIt

constexpr

Copies the elements from the range [first, last), to another range beginning at d_first in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied.

Elements are compared using the given binary predicate pred. The behavior is undefined if it is not an equivalence relation.

upper_bound() [1/2]

template<typename ForwardIt, typename T>

auto upper_bound ( ForwardIt first, ForwardIt last, T const & value ) -> ForwardIt

nodiscardconstexpr

Returns an iterator pointing to the first element in the range [first, last) that is greater than value, or last if no such element is found.

The range [first, last) must be partitioned with respect to the expression not (value < element) or not comp(value, element), i.e., all elements for which the expression is true must precede all elements for which the expression is false. A fully-sorted range meets this criterion.

upper_bound() [2/2]

template<typename ForwardIt, typename T, typename Compare>

auto upper_bound ( ForwardIt first, ForwardIt last, T const & value, Compare comp ) -> ForwardIt

nodiscardconstexpr

Returns an iterator pointing to the first element in the range [first, last) that is greater than value, or last if no such element is found.

The range [first, last) must be partitioned with respect to the expression not (value < element) or not comp(value, element), i.e., all elements for which the expression is true must precede all elements for which the expression is false. A fully-sorted range meets this criterion.