Range-v3
Range algorithms, views, and actions for the Standard Library
Algorithms

Description

Iterator- and range-based algorithms, like the standard algorithms.

Classes

struct  ranges::v3::adjacent_find_fn
 
struct  ranges::v3::all_of_fn
 
struct  ranges::v3::any_of_fn
 
struct  ranges::v3::binary_search_fn
 
struct  ranges::v3::copy_backward_fn
 
struct  ranges::v3::copy_fn
 
struct  ranges::v3::copy_if_fn
 
struct  ranges::v3::copy_n_fn
 
struct  ranges::v3::count_fn
 
struct  ranges::v3::count_if_fn
 
struct  ranges::v3::equal_fn
 
struct  ranges::v3::equal_range_fn
 
struct  ranges::v3::fill_fn
 
struct  ranges::v3::fill_n_fn
 
struct  ranges::v3::find_end_fn
 
struct  ranges::v3::find_first_of_fn
 
struct  ranges::v3::find_fn
 
struct  ranges::v3::find_if_fn
 
struct  ranges::v3::find_if_not_fn
 
struct  ranges::v3::for_each_fn
 
struct  ranges::v3::for_each_n_fn
 
struct  ranges::v3::generate_fn
 
struct  ranges::v3::generate_n_fn
 
struct  ranges::v3::includes_fn
 
struct  ranges::v3::inplace_merge_fn
 
struct  ranges::v3::is_heap_fn
 
struct  ranges::v3::is_heap_until_fn
 
struct  ranges::v3::is_partitioned_fn
 
struct  ranges::v3::is_permutation_fn
 
struct  ranges::v3::is_sorted_fn
 
struct  ranges::v3::is_sorted_until_fn
 
struct  ranges::v3::lexicographical_compare_fn
 
struct  ranges::v3::lower_bound_fn
 
struct  ranges::v3::make_heap_fn
 
struct  ranges::v3::max_element_fn
 
struct  ranges::v3::max_fn
 
struct  ranges::v3::merge_fn
 
struct  ranges::v3::min_element_fn
 
struct  ranges::v3::min_fn
 
struct  ranges::v3::minmax_element_fn
 
struct  ranges::v3::minmax_fn
 
struct  ranges::v3::mismatch_fn
 
struct  ranges::v3::move_backward_fn
 
struct  ranges::v3::move_fn
 
struct  ranges::v3::next_permutation_fn
 
struct  ranges::v3::none_of_fn
 
struct  ranges::v3::nth_element_fn
 
struct  ranges::v3::partial_sort_copy_fn
 
struct  ranges::v3::partial_sort_fn
 
struct  ranges::v3::partition_copy_fn
 
struct  ranges::v3::partition_fn
 
struct  ranges::v3::partition_point_fn
 
struct  ranges::v3::pop_heap_fn
 
struct  ranges::v3::prev_permutation_fn
 
struct  ranges::v3::push_heap_fn
 
struct  ranges::v3::remove_copy_fn
 
struct  ranges::v3::remove_copy_if_fn
 
struct  ranges::v3::remove_fn
 
struct  ranges::v3::remove_if_fn
 
struct  ranges::v3::replace_copy_fn
 
struct  ranges::v3::replace_copy_if_fn
 
struct  ranges::v3::replace_fn
 
struct  ranges::v3::replace_if_fn
 
struct  ranges::v3::reverse_copy_fn
 
struct  ranges::v3::reverse_fn
 
struct  ranges::v3::rotate_copy_fn
 
struct  ranges::v3::rotate_fn
 
class  ranges::v3::sample_fn
 
struct  ranges::v3::search_fn
 
struct  ranges::v3::search_n_fn
 
struct  ranges::v3::set_difference_fn
 
struct  ranges::v3::set_intersection_fn
 
struct  ranges::v3::set_symmetric_difference_fn
 
struct  ranges::v3::set_union_fn
 
struct  ranges::v3::shuffle_fn
 
struct  ranges::v3::sort_fn
 
struct  ranges::v3::sort_heap_fn
 
struct  ranges::v3::stable_partition_fn
 
struct  ranges::v3::stable_sort_fn
 
struct  ranges::v3::swap_ranges_fn
 
struct  ranges::v3::transform_fn
 
struct  ranges::v3::unique_copy_fn
 
struct  ranges::v3::unique_fn
 
struct  ranges::v3::upper_bound_fn
 

Variables

constexpr with_braced_init_args< adjacent_find_fnranges::v3::adjacent_find {}
 
constexpr with_braced_init_args< all_of_fnranges::v3::all_of {}
 
constexpr with_braced_init_args< any_of_fnranges::v3::any_of {}
 
constexpr with_braced_init_args< binary_search_fnranges::v3::binary_search {}
 
constexpr with_braced_init_args< copy_fnranges::v3::copy {}
 
constexpr with_braced_init_args< copy_backward_fnranges::v3::copy_backward {}
 
constexpr with_braced_init_args< copy_if_fnranges::v3::copy_if {}
 
constexpr with_braced_init_args< copy_n_fnranges::v3::copy_n {}
 
constexpr with_braced_init_args< with_braced_init_args< count_fn > > ranges::v3::count {}
 
constexpr with_braced_init_args< count_if_fnranges::v3::count_if {}
 
constexpr with_braced_init_args< equal_fnranges::v3::equal {}
 
constexpr with_braced_init_args< equal_range_fnranges::v3::equal_range {}
 
constexpr with_braced_init_args< fill_fnranges::v3::fill {}
 
constexpr fill_n_fn ranges::v3::fill_n {}
 
constexpr with_braced_init_args< find_fnranges::v3::find {}
 
constexpr with_braced_init_args< find_end_fnranges::v3::find_end {}
 
constexpr with_braced_init_args< find_first_of_fnranges::v3::find_first_of {}
 
constexpr with_braced_init_args< find_if_fnranges::v3::find_if {}
 
constexpr with_braced_init_args< find_if_not_fnranges::v3::find_if_not {}
 
constexpr with_braced_init_args< for_each_fnranges::v3::for_each {}
 
constexpr with_braced_init_args< for_each_n_fnranges::v3::for_each_n {}
 
constexpr with_braced_init_args< generate_fnranges::v3::generate {}
 
constexpr generate_n_fn ranges::v3::generate_n {}
 
constexpr with_braced_init_args< includes_fnranges::v3::includes {}
 
constexpr with_braced_init_args< inplace_merge_fnranges::v3::inplace_merge {}
 
constexpr with_braced_init_args< is_heap_fnranges::v3::is_heap {}
 
constexpr with_braced_init_args< is_heap_until_fnranges::v3::is_heap_until {}
 
constexpr with_braced_init_args< is_partitioned_fnranges::v3::is_partitioned {}
 
constexpr with_braced_init_args< is_permutation_fnranges::v3::is_permutation {}
 
constexpr with_braced_init_args< is_sorted_fnranges::v3::is_sorted {}
 
constexpr with_braced_init_args< is_sorted_until_fnranges::v3::is_sorted_until {}
 
constexpr with_braced_init_args< lexicographical_compare_fnranges::v3::lexicographical_compare {}
 
constexpr with_braced_init_args< lower_bound_fnranges::v3::lower_bound {}
 
constexpr with_braced_init_args< make_heap_fnranges::v3::make_heap {}
 
constexpr with_braced_init_args< max_fnranges::v3::max {}
 
constexpr with_braced_init_args< max_element_fnranges::v3::max_element {}
 
constexpr with_braced_init_args< merge_fnranges::v3::merge {}
 
constexpr with_braced_init_args< min_fnranges::v3::min {}
 
constexpr with_braced_init_args< min_element_fnranges::v3::min_element {}
 
constexpr with_braced_init_args< minmax_fnranges::v3::minmax {}
 
constexpr with_braced_init_args< minmax_element_fnranges::v3::minmax_element {}
 
constexpr with_braced_init_args< mismatch_fnranges::v3::mismatch {}
 
constexpr with_braced_init_args< move_fnranges::v3::move {}
 
constexpr with_braced_init_args< move_backward_fnranges::v3::move_backward {}
 
constexpr with_braced_init_args< next_permutation_fnranges::v3::next_permutation {}
 
constexpr with_braced_init_args< none_of_fnranges::v3::none_of {}
 
constexpr with_braced_init_args< nth_element_fnranges::v3::nth_element {}
 
constexpr with_braced_init_args< partial_sort_fnranges::v3::partial_sort {}
 
constexpr with_braced_init_args< partial_sort_copy_fnranges::v3::partial_sort_copy {}
 
constexpr with_braced_init_args< partition_fnranges::v3::partition {}
 
constexpr with_braced_init_args< partition_copy_fnranges::v3::partition_copy {}
 
constexpr with_braced_init_args< partition_point_fnranges::v3::partition_point {}
 
constexpr with_braced_init_args< pop_heap_fnranges::v3::pop_heap {}
 
constexpr with_braced_init_args< prev_permutation_fnranges::v3::prev_permutation {}
 
constexpr with_braced_init_args< push_heap_fnranges::v3::push_heap {}
 
constexpr with_braced_init_args< remove_fnranges::v3::remove {}
 
constexpr with_braced_init_args< remove_copy_fnranges::v3::remove_copy {}
 
constexpr with_braced_init_args< remove_copy_if_fnranges::v3::remove_copy_if {}
 
constexpr with_braced_init_args< remove_if_fnranges::v3::remove_if {}
 
constexpr with_braced_init_args< replace_fnranges::v3::replace {}
 
constexpr with_braced_init_args< replace_copy_fnranges::v3::replace_copy {}
 
constexpr with_braced_init_args< replace_copy_if_fnranges::v3::replace_copy_if {}
 
constexpr with_braced_init_args< replace_if_fnranges::v3::replace_if {}
 
constexpr with_braced_init_args< reverse_fnranges::v3::reverse {}
 
constexpr with_braced_init_args< reverse_copy_fnranges::v3::reverse_copy {}
 
constexpr with_braced_init_args< rotate_fnranges::v3::rotate {}
 
constexpr with_braced_init_args< rotate_copy_fnranges::v3::rotate_copy {}
 
constexpr with_braced_init_args< sample_fnranges::v3::sample {}
 
constexpr with_braced_init_args< search_fnranges::v3::search {}
 
constexpr with_braced_init_args< search_n_fnranges::v3::search_n {}
 
constexpr with_braced_init_args< set_difference_fnranges::v3::set_difference {}
 
constexpr with_braced_init_args< set_intersection_fnranges::v3::set_intersection {}
 
constexpr with_braced_init_args< set_symmetric_difference_fnranges::v3::set_symmetric_difference {}
 
constexpr with_braced_init_args< set_union_fnranges::v3::set_union {}
 
constexpr with_braced_init_args< shuffle_fnranges::v3::shuffle {}
 
constexpr with_braced_init_args< sort_fnranges::v3::sort {}
 
constexpr with_braced_init_args< sort_heap_fnranges::v3::sort_heap {}
 
constexpr with_braced_init_args< stable_partition_fnranges::v3::stable_partition {}
 
constexpr with_braced_init_args< stable_sort_fnranges::v3::stable_sort {}
 
constexpr with_braced_init_args< swap_ranges_fnranges::v3::swap_ranges {}
 
constexpr with_braced_init_args< transform_fnranges::v3::transform {}
 
constexpr with_braced_init_args< unique_fnranges::v3::unique {}
 
constexpr with_braced_init_args< unique_copy_fnranges::v3::unique_copy {}
 
constexpr with_braced_init_args< upper_bound_fnranges::v3::upper_bound {}
 

Variable Documentation

◆ adjacent_find

◆ all_of

constexpr with_braced_init_args<all_of_fn> ranges::v3::all_of {}

◆ any_of

constexpr with_braced_init_args<any_of_fn> ranges::v3::any_of {}

◆ binary_search

constexpr with_braced_init_args<binary_search_fn> ranges::v3::binary_search {}

◆ copy

◆ copy_backward

constexpr with_braced_init_args<copy_backward_fn> ranges::v3::copy_backward {}

◆ copy_if

constexpr with_braced_init_args<copy_if_fn> ranges::v3::copy_if {}

◆ copy_n

constexpr with_braced_init_args<copy_n_fn> ranges::v3::copy_n {}

◆ count

constexpr with_braced_init_args<with_braced_init_args<count_fn> > ranges::v3::count {}

◆ count_if

constexpr with_braced_init_args<count_if_fn> ranges::v3::count_if {}

◆ equal

◆ equal_range

constexpr with_braced_init_args<equal_range_fn> ranges::v3::equal_range {}

◆ fill

constexpr with_braced_init_args<fill_fn> ranges::v3::fill {}

◆ fill_n

constexpr fill_n_fn ranges::v3::fill_n {}

◆ find

constexpr with_braced_init_args<find_fn> ranges::v3::find {}

◆ find_end

constexpr with_braced_init_args<find_end_fn> ranges::v3::find_end {}

◆ find_first_of

constexpr with_braced_init_args<find_first_of_fn> ranges::v3::find_first_of {}

◆ find_if

constexpr with_braced_init_args<find_if_fn> ranges::v3::find_if {}

◆ find_if_not

constexpr with_braced_init_args<find_if_not_fn> ranges::v3::find_if_not {}

◆ for_each

constexpr with_braced_init_args<for_each_fn> ranges::v3::for_each {}
related

◆ for_each_n

constexpr with_braced_init_args<for_each_n_fn> ranges::v3::for_each_n {}

◆ generate

constexpr with_braced_init_args<generate_fn> ranges::v3::generate {}
related

◆ generate_n

constexpr generate_n_fn ranges::v3::generate_n {}
related

◆ includes

constexpr with_braced_init_args<includes_fn> ranges::v3::includes {}

◆ inplace_merge

constexpr with_braced_init_args<inplace_merge_fn> ranges::v3::inplace_merge {}

◆ is_heap

constexpr with_braced_init_args<is_heap_fn> ranges::v3::is_heap {}

◆ is_heap_until

constexpr with_braced_init_args<is_heap_until_fn> ranges::v3::is_heap_until {}

◆ is_partitioned

constexpr with_braced_init_args<is_partitioned_fn> ranges::v3::is_partitioned {}

◆ is_permutation

constexpr with_braced_init_args<is_permutation_fn> ranges::v3::is_permutation {}

◆ is_sorted

constexpr with_braced_init_args<is_sorted_fn> ranges::v3::is_sorted {}

◆ is_sorted_until

◆ lexicographical_compare

◆ lower_bound

◆ make_heap

constexpr with_braced_init_args<make_heap_fn> ranges::v3::make_heap {}

◆ max

constexpr with_braced_init_args<max_fn> ranges::v3::max {}

#include <range/v3/algorithm/max.hpp>

See also
max_fn

◆ max_element

constexpr with_braced_init_args<max_element_fn> ranges::v3::max_element {}

◆ merge

constexpr with_braced_init_args<merge_fn> ranges::v3::merge {}

◆ min

constexpr with_braced_init_args<min_fn> ranges::v3::min {}

#include <range/v3/algorithm/min.hpp>

See also
min_fn

◆ min_element

constexpr with_braced_init_args<min_element_fn> ranges::v3::min_element {}

◆ minmax

constexpr with_braced_init_args<minmax_fn> ranges::v3::minmax {}

◆ minmax_element

constexpr with_braced_init_args<minmax_element_fn> ranges::v3::minmax_element {}

◆ mismatch

constexpr with_braced_init_args<mismatch_fn> ranges::v3::mismatch {}

◆ move

◆ move_backward

constexpr with_braced_init_args<move_backward_fn> ranges::v3::move_backward {}

◆ next_permutation

constexpr with_braced_init_args<next_permutation_fn> ranges::v3::next_permutation {}

◆ none_of

constexpr with_braced_init_args<none_of_fn> ranges::v3::none_of {}

◆ nth_element

constexpr with_braced_init_args<nth_element_fn> ranges::v3::nth_element {}

◆ partial_sort

constexpr with_braced_init_args<partial_sort_fn> ranges::v3::partial_sort {}

◆ partial_sort_copy

constexpr with_braced_init_args<partial_sort_copy_fn> ranges::v3::partial_sort_copy {}

◆ partition

constexpr with_braced_init_args<partition_fn> ranges::v3::partition {}

◆ partition_copy

constexpr with_braced_init_args<partition_copy_fn> ranges::v3::partition_copy {}

◆ partition_point

◆ pop_heap

constexpr with_braced_init_args<pop_heap_fn> ranges::v3::pop_heap {}

◆ prev_permutation

constexpr with_braced_init_args<prev_permutation_fn> ranges::v3::prev_permutation {}

◆ push_heap

constexpr with_braced_init_args<push_heap_fn> ranges::v3::push_heap {}

◆ remove

constexpr with_braced_init_args<remove_fn> ranges::v3::remove {}

◆ remove_copy

constexpr with_braced_init_args<remove_copy_fn> ranges::v3::remove_copy {}

◆ remove_copy_if

constexpr with_braced_init_args<remove_copy_if_fn> ranges::v3::remove_copy_if {}

◆ remove_if

constexpr with_braced_init_args<remove_if_fn> ranges::v3::remove_if {}
related

◆ replace

constexpr with_braced_init_args<replace_fn> ranges::v3::replace {}
related

◆ replace_copy

constexpr with_braced_init_args<replace_copy_fn> ranges::v3::replace_copy {}

◆ replace_copy_if

constexpr with_braced_init_args<replace_copy_if_fn> ranges::v3::replace_copy_if {}

◆ replace_if

constexpr with_braced_init_args<replace_if_fn> ranges::v3::replace_if {}
related

◆ reverse

constexpr with_braced_init_args<reverse_fn> ranges::v3::reverse {}
related

◆ reverse_copy

constexpr with_braced_init_args<reverse_copy_fn> ranges::v3::reverse_copy {}

◆ rotate

constexpr with_braced_init_args<rotate_fn> ranges::v3::rotate {}

◆ rotate_copy

constexpr with_braced_init_args<rotate_copy_fn> ranges::v3::rotate_copy {}

◆ sample

constexpr with_braced_init_args<sample_fn> ranges::v3::sample {}
related

◆ search

constexpr with_braced_init_args<search_fn> ranges::v3::search {}

◆ search_n

constexpr with_braced_init_args<search_n_fn> ranges::v3::search_n {}

◆ set_difference

constexpr with_braced_init_args<set_difference_fn> ranges::v3::set_difference {}
related

◆ set_intersection

constexpr with_braced_init_args<set_intersection_fn> ranges::v3::set_intersection {}
related

◆ set_symmetric_difference

constexpr with_braced_init_args<set_symmetric_difference_fn> ranges::v3::set_symmetric_difference {}
related

◆ set_union

constexpr with_braced_init_args<set_union_fn> ranges::v3::set_union {}
related

◆ shuffle

constexpr with_braced_init_args<shuffle_fn> ranges::v3::shuffle {}
related

◆ sort

constexpr with_braced_init_args<sort_fn> ranges::v3::sort {}
related

◆ sort_heap

constexpr with_braced_init_args<sort_heap_fn> ranges::v3::sort_heap {}

◆ stable_partition

constexpr with_braced_init_args<stable_partition_fn> ranges::v3::stable_partition {}

◆ stable_sort

constexpr with_braced_init_args<stable_sort_fn> ranges::v3::stable_sort {}
related

◆ swap_ranges

constexpr with_braced_init_args<swap_ranges_fn> ranges::v3::swap_ranges {}

◆ transform

constexpr with_braced_init_args<transform_fn> ranges::v3::transform {}
related

◆ unique

constexpr with_braced_init_args<unique_fn> ranges::v3::unique {}
related

◆ unique_copy

constexpr with_braced_init_args<unique_copy_fn> ranges::v3::unique_copy {}

◆ upper_bound

constexpr with_braced_init_args<upper_bound_fn> ranges::v3::upper_bound {}