%!TEX root = std.tex

\rSec0[algorithms]{Algorithms library}

\rSec1[algorithms.general]{General}

\pnum

This Clause describes components that \Cpp{} programs may use to perform

algorithmic operations on containers\iref{containers} and other sequences.

\pnum

The following subclauses describe components for

non-modifying sequence operations,

mutating sequence operations,

sorting and related operations,

and algorithms from the ISO C library,

as summarized in Table~\ref{tab:algorithms.summary}.

\begin{libsumtab}{Algorithms library summary}{tab:algorithms.summary}

\ref{alg.nonmodifying} & Non-modifying sequence operations & \\

\ref{alg.modifying.operations} & Mutating sequence operations & \tcode{<algorithm>} \\

\ref{alg.sorting} & Sorting and related operations & \\ \hline

\ref{alg.c.library} & C library algorithms & \tcode{<cstdlib>} \\ \hline

\end{libsumtab}

\rSec1[algorithm.syn]{Header \tcode{<algorithm>} synopsis}

\indexhdr{algorithm}%

\begin{codeblock}

#include <initializer_list>

namespace std {

// \ref{alg.nonmodifying}, non-modifying sequence operations

// \ref{alg.all_of}, all of

template<class InputIterator, class Predicate>

constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

bool all_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

// \ref{alg.any_of}, any of

template<class InputIterator, class Predicate>

constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

bool any_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

// \ref{alg.none_of}, none of

template<class InputIterator, class Predicate>

constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

bool none_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

// \ref{alg.foreach}, for each

template<class InputIterator, class Function>

constexpr Function for_each(InputIterator first, InputIterator last, Function f);

template<class ExecutionPolicy, class ForwardIterator, class Function>

void for_each(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Function f);

template<class InputIterator, class Size, class Function>

constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>

ForwardIterator for_each_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, Size n, Function f);

// \ref{alg.find}, find

template<class InputIterator, class T>

constexpr InputIterator find(InputIterator first, InputIterator last,

const T& value);

template<class ExecutionPolicy, class ForwardIterator, class T>

ForwardIterator find(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

const T& value);

template<class InputIterator, class Predicate>

constexpr InputIterator find_if(InputIterator first, InputIterator last,

Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

ForwardIterator find_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Predicate pred);

template<class InputIterator, class Predicate>

constexpr InputIterator find_if_not(InputIterator first, InputIterator last,

Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

ForwardIterator find_if_not(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Predicate pred);

// \ref{alg.find.end}, find end

template<class ForwardIterator1, class ForwardIterator2>

constexpr ForwardIterator1

find_end(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>

constexpr ForwardIterator1

find_end(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator1

find_end(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1,

class ForwardIterator2, class BinaryPredicate>

ForwardIterator1

find_end(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

// \ref{alg.find.first.of}, find first

template<class InputIterator, class ForwardIterator>

constexpr InputIterator

find_first_of(InputIterator first1, InputIterator last1,

ForwardIterator first2, ForwardIterator last2);

template<class InputIterator, class ForwardIterator, class BinaryPredicate>

constexpr InputIterator

find_first_of(InputIterator first1, InputIterator last1,

ForwardIterator first2, ForwardIterator last2,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator1

find_first_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1,

class ForwardIterator2, class BinaryPredicate>

ForwardIterator1

find_first_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

// \ref{alg.adjacent.find}, adjacent find

template<class ForwardIterator>

constexpr ForwardIterator

adjacent_find(ForwardIterator first, ForwardIterator last);

template<class ForwardIterator, class BinaryPredicate>

constexpr ForwardIterator

adjacent_find(ForwardIterator first, ForwardIterator last,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator>

ForwardIterator

adjacent_find(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>

ForwardIterator

adjacent_find(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

BinaryPredicate pred);

// \ref{alg.count}, count

template<class InputIterator, class T>

constexpr typename iterator_traits<InputIterator>::difference_type

count(InputIterator first, InputIterator last, const T& value);

template<class ExecutionPolicy, class ForwardIterator, class T>

typename iterator_traits<ForwardIterator>::difference_type

count(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, const T& value);

template<class InputIterator, class Predicate>

constexpr typename iterator_traits<InputIterator>::difference_type

count_if(InputIterator first, InputIterator last, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

typename iterator_traits<ForwardIterator>::difference_type

count_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

// \ref{mismatch}, mismatch

template<class InputIterator1, class InputIterator2>

constexpr pair<InputIterator1, InputIterator2>

mismatch(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2);

template<class InputIterator1, class InputIterator2, class BinaryPredicate>

constexpr pair<InputIterator1, InputIterator2>

mismatch(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, BinaryPredicate pred);

template<class InputIterator1, class InputIterator2>

constexpr pair<InputIterator1, InputIterator2>

mismatch(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2);

template<class InputIterator1, class InputIterator2, class BinaryPredicate>

constexpr pair<InputIterator1, InputIterator2>

mismatch(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

pair<ForwardIterator1, ForwardIterator2>

mismatch(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class BinaryPredicate>

pair<ForwardIterator1, ForwardIterator2>

mismatch(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

pair<ForwardIterator1, ForwardIterator2>

mismatch(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class BinaryPredicate>

pair<ForwardIterator1, ForwardIterator2>

mismatch(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

// \ref{alg.equal}, equal

template<class InputIterator1, class InputIterator2>

constexpr bool equal(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2);

template<class InputIterator1, class InputIterator2, class BinaryPredicate>

constexpr bool equal(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, BinaryPredicate pred);

template<class InputIterator1, class InputIterator2>

constexpr bool equal(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2);

template<class InputIterator1, class InputIterator2, class BinaryPredicate>

constexpr bool equal(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

bool equal(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class BinaryPredicate>

bool equal(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

bool equal(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class BinaryPredicate>

bool equal(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

// \ref{alg.is_permutation}, is permutation

template<class ForwardIterator1, class ForwardIterator2>

constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2);

template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>

constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, BinaryPredicate pred);

template<class ForwardIterator1, class ForwardIterator2>

constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>

constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

// \ref{alg.search}, search

template<class ForwardIterator1, class ForwardIterator2>

constexpr ForwardIterator1

search(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>

constexpr ForwardIterator1

search(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator1

search(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class BinaryPredicate>

ForwardIterator1

search(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

BinaryPredicate pred);

template<class ForwardIterator, class Size, class T>

constexpr ForwardIterator

search_n(ForwardIterator first, ForwardIterator last,

Size count, const T& value);

template<class ForwardIterator, class Size, class T, class BinaryPredicate>

constexpr ForwardIterator

search_n(ForwardIterator first, ForwardIterator last,

Size count, const T& value,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Size, class T>

ForwardIterator

search_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Size count, const T& value);

template<class ExecutionPolicy, class ForwardIterator, class Size, class T,

class BinaryPredicate>

ForwardIterator

search_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Size count, const T& value,

BinaryPredicate pred);

template<class ForwardIterator, class Searcher>

constexpr ForwardIterator

search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);

// \ref{alg.modifying.operations}, mutating sequence operations

// \ref{alg.copy}, copy

template<class InputIterator, class OutputIterator>

constexpr OutputIterator copy(InputIterator first, InputIterator last,

OutputIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator2 copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result);

template<class InputIterator, class Size, class OutputIterator>

constexpr OutputIterator copy_n(InputIterator first, Size n,

OutputIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class Size,

class ForwardIterator2>

ForwardIterator2 copy_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, Size n,

ForwardIterator2 result);

template<class InputIterator, class OutputIterator, class Predicate>

constexpr OutputIterator copy_if(InputIterator first, InputIterator last,

OutputIterator result, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class Predicate>

ForwardIterator2 copy_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result, Predicate pred);

template<class BidirectionalIterator1, class BidirectionalIterator2>

constexpr BidirectionalIterator2

copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,

BidirectionalIterator2 result);

// \ref{alg.move}, move

template<class InputIterator, class OutputIterator>

constexpr OutputIterator move(InputIterator first, InputIterator last,

OutputIterator result);

template<class ExecutionPolicy, class ForwardIterator1,

class ForwardIterator2>

ForwardIterator2 move(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result);

template<class BidirectionalIterator1, class BidirectionalIterator2>

constexpr BidirectionalIterator2

move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,

BidirectionalIterator2 result);

// \ref{alg.swap}, swap

template<class ForwardIterator1, class ForwardIterator2>

ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator2 swap_ranges(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2);

template<class ForwardIterator1, class ForwardIterator2>

void iter_swap(ForwardIterator1 a, ForwardIterator2 b);

// \ref{alg.transform}, transform

template<class InputIterator, class OutputIterator, class UnaryOperation>

constexpr OutputIterator

transform(InputIterator first, InputIterator last,

OutputIterator result, UnaryOperation op);

template<class InputIterator1, class InputIterator2, class OutputIterator,

class BinaryOperation>

constexpr OutputIterator

transform(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, OutputIterator result,

BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class UnaryOperation>

ForwardIterator2

transform(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result, UnaryOperation op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator, class BinaryOperation>

ForwardIterator

transform(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator result,

BinaryOperation binary_op);

// \ref{alg.replace}, replace

template<class ForwardIterator, class T>

constexpr void replace(ForwardIterator first, ForwardIterator last,

const T& old_value, const T& new_value);

template<class ExecutionPolicy, class ForwardIterator, class T>

void replace(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

const T& old_value, const T& new_value);

template<class ForwardIterator, class Predicate, class T>

constexpr void replace_if(ForwardIterator first, ForwardIterator last,

Predicate pred, const T& new_value);

template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T>

void replace_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Predicate pred, const T& new_value);

template<class InputIterator, class OutputIterator, class T>

constexpr OutputIterator replace_copy(InputIterator first, InputIterator last,

OutputIterator result,

const T& old_value, const T& new_value);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>

ForwardIterator2 replace_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result,

const T& old_value, const T& new_value);

template<class InputIterator, class OutputIterator, class Predicate, class T>

constexpr OutputIterator replace_copy_if(InputIterator first, InputIterator last,

OutputIterator result,

Predicate pred, const T& new_value);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class Predicate, class T>

ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result,

Predicate pred, const T& new_value);

// \ref{alg.fill}, fill

template<class ForwardIterator, class T>

constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);

template<class ExecutionPolicy, class ForwardIterator, class T>

void fill(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, const T& value);

template<class OutputIterator, class Size, class T>

constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);

template<class ExecutionPolicy, class ForwardIterator,

class Size, class T>

ForwardIterator fill_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, Size n, const T& value);

// \ref{alg.generate}, generate

template<class ForwardIterator, class Generator>

constexpr void generate(ForwardIterator first, ForwardIterator last,

Generator gen);

template<class ExecutionPolicy, class ForwardIterator, class Generator>

void generate(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Generator gen);

template<class OutputIterator, class Size, class Generator>

constexpr OutputIterator generate_n(OutputIterator first, Size n, Generator gen);

template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>

ForwardIterator generate_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, Size n, Generator gen);

// \ref{alg.remove}, remove

template<class ForwardIterator, class T>

constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,

const T& value);

template<class ExecutionPolicy, class ForwardIterator, class T>

ForwardIterator remove(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

const T& value);

template<class ForwardIterator, class Predicate>

constexpr ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,

Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

ForwardIterator remove_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Predicate pred);

template<class InputIterator, class OutputIterator, class T>

constexpr OutputIterator

remove_copy(InputIterator first, InputIterator last,

OutputIterator result, const T& value);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class T>

ForwardIterator2

remove_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result, const T& value);

template<class InputIterator, class OutputIterator, class Predicate>

constexpr OutputIterator

remove_copy_if(InputIterator first, InputIterator last,

OutputIterator result, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class Predicate>

ForwardIterator2

remove_copy_if(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result, Predicate pred);

// \ref{alg.unique}, unique

template<class ForwardIterator>

constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last);

template<class ForwardIterator, class BinaryPredicate>

constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last,

BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator>

ForwardIterator unique(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>

ForwardIterator unique(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

BinaryPredicate pred);

template<class InputIterator, class OutputIterator>

constexpr OutputIterator

unique_copy(InputIterator first, InputIterator last,

OutputIterator result);

template<class InputIterator, class OutputIterator, class BinaryPredicate>

constexpr OutputIterator

unique_copy(InputIterator first, InputIterator last,

OutputIterator result, BinaryPredicate pred);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator2

unique_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class BinaryPredicate>

ForwardIterator2

unique_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 last,

ForwardIterator2 result, BinaryPredicate pred);

// \ref{alg.reverse}, reverse

template<class BidirectionalIterator>

void reverse(BidirectionalIterator first, BidirectionalIterator last);

template<class ExecutionPolicy, class BidirectionalIterator>

void reverse(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

BidirectionalIterator first, BidirectionalIterator last);

template<class BidirectionalIterator, class OutputIterator>

constexpr OutputIterator

reverse_copy(BidirectionalIterator first, BidirectionalIterator last,

OutputIterator result);

template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>

ForwardIterator

reverse_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

BidirectionalIterator first, BidirectionalIterator last,

ForwardIterator result);

// \ref{alg.rotate}, rotate

template<class ForwardIterator>

ForwardIterator rotate(ForwardIterator first,

ForwardIterator middle,

ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator>

ForwardIterator rotate(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first,

ForwardIterator middle,

ForwardIterator last);

template<class ForwardIterator, class OutputIterator>

constexpr OutputIterator

rotate_copy(ForwardIterator first, ForwardIterator middle,

ForwardIterator last, OutputIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

ForwardIterator2

rotate_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first, ForwardIterator1 middle,

ForwardIterator1 last, ForwardIterator2 result);

// \ref{alg.random.sample}, sample

template<class PopulationIterator, class SampleIterator,

class Distance, class UniformRandomBitGenerator>

SampleIterator sample(PopulationIterator first, PopulationIterator last,

SampleIterator out, Distance n,

UniformRandomBitGenerator&& g);

// \ref{alg.random.shuffle}, shuffle

template<class RandomAccessIterator, class UniformRandomBitGenerator>

void shuffle(RandomAccessIterator first,

RandomAccessIterator last,

UniformRandomBitGenerator&& g);

// \ref{alg.partitions}, partitions

template<class InputIterator, class Predicate>

constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

bool is_partitioned(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last, Predicate pred);

template<class ForwardIterator, class Predicate>

ForwardIterator partition(ForwardIterator first,

ForwardIterator last,

Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class Predicate>

ForwardIterator partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first,

ForwardIterator last,

Predicate pred);

template<class BidirectionalIterator, class Predicate>

BidirectionalIterator stable_partition(BidirectionalIterator first,

BidirectionalIterator last,

Predicate pred);

template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>

BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

BidirectionalIterator first,

BidirectionalIterator last,

Predicate pred);

template<class InputIterator, class OutputIterator1,

class OutputIterator2, class Predicate>

constexpr pair<OutputIterator1, OutputIterator2>

partition_copy(InputIterator first, InputIterator last,

OutputIterator1 out_true, OutputIterator2 out_false,

Predicate pred);

template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,

class ForwardIterator2, class Predicate>

pair<ForwardIterator1, ForwardIterator2>

partition_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

ForwardIterator1 out_true, ForwardIterator2 out_false,

Predicate pred);

template<class ForwardIterator, class Predicate>

constexpr ForwardIterator

partition_point(ForwardIterator first, ForwardIterator last,

Predicate pred);

// \ref{alg.sorting}, sorting and related operations

// \ref{alg.sort}, sorting

template<class RandomAccessIterator>

void sort(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void sort(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class ExecutionPolicy, class RandomAccessIterator>

void sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>

void sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void stable_sort(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class ExecutionPolicy, class RandomAccessIterator>

void stable_sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>

void stable_sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

void partial_sort(RandomAccessIterator first,

RandomAccessIterator middle,

RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void partial_sort(RandomAccessIterator first,

RandomAccessIterator middle,

RandomAccessIterator last, Compare comp);

template<class ExecutionPolicy, class RandomAccessIterator>

void partial_sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first,

RandomAccessIterator middle,

RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>

void partial_sort(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first,

RandomAccessIterator middle,

RandomAccessIterator last, Compare comp);

template<class InputIterator, class RandomAccessIterator>

RandomAccessIterator

partial_sort_copy(InputIterator first, InputIterator last,

RandomAccessIterator result_first,

RandomAccessIterator result_last);

template<class InputIterator, class RandomAccessIterator, class Compare>

RandomAccessIterator

partial_sort_copy(InputIterator first, InputIterator last,

RandomAccessIterator result_first,

RandomAccessIterator result_last,

Compare comp);

template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>

RandomAccessIterator

partial_sort_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

RandomAccessIterator result_first,

RandomAccessIterator result_last);

template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,

class Compare>

RandomAccessIterator

partial_sort_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

RandomAccessIterator result_first,

RandomAccessIterator result_last,

Compare comp);

template<class ForwardIterator>

constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);

template<class ForwardIterator, class Compare>

constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,

Compare comp);

template<class ExecutionPolicy, class ForwardIterator>

bool is_sorted(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>

bool is_sorted(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Compare comp);

template<class ForwardIterator>

constexpr ForwardIterator

is_sorted_until(ForwardIterator first, ForwardIterator last);

template<class ForwardIterator, class Compare>

constexpr ForwardIterator

is_sorted_until(ForwardIterator first, ForwardIterator last,

Compare comp);

template<class ExecutionPolicy, class ForwardIterator>

ForwardIterator

is_sorted_until(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Compare>

ForwardIterator

is_sorted_until(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator first, ForwardIterator last,

Compare comp);

// \ref{alg.nth.element}, Nth element

template<class RandomAccessIterator>

void nth_element(RandomAccessIterator first, RandomAccessIterator nth,

RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void nth_element(RandomAccessIterator first, RandomAccessIterator nth,

RandomAccessIterator last, Compare comp);

template<class ExecutionPolicy, class RandomAccessIterator>

void nth_element(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator nth,

RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>

void nth_element(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator nth,

RandomAccessIterator last, Compare comp);

// \ref{alg.binary.search}, binary search

template<class ForwardIterator, class T>

constexpr ForwardIterator

lower_bound(ForwardIterator first, ForwardIterator last,

const T& value);

template<class ForwardIterator, class T, class Compare>

constexpr ForwardIterator

lower_bound(ForwardIterator first, ForwardIterator last,

const T& value, Compare comp);

template<class ForwardIterator, class T>

constexpr ForwardIterator

upper_bound(ForwardIterator first, ForwardIterator last,

const T& value);

template<class ForwardIterator, class T, class Compare>

constexpr ForwardIterator

upper_bound(ForwardIterator first, ForwardIterator last,

const T& value, Compare comp);

template<class ForwardIterator, class T>

constexpr pair<ForwardIterator, ForwardIterator>

equal_range(ForwardIterator first, ForwardIterator last,

const T& value);

template<class ForwardIterator, class T, class Compare>

constexpr pair<ForwardIterator, ForwardIterator>

equal_range(ForwardIterator first, ForwardIterator last,

const T& value, Compare comp);

template<class ForwardIterator, class T>

constexpr bool

binary_search(ForwardIterator first, ForwardIterator last,

const T& value);

template<class ForwardIterator, class T, class Compare>

constexpr bool

binary_search(ForwardIterator first, ForwardIterator last,

const T& value, Compare comp);

// \ref{alg.merge}, merge

template<class InputIterator1, class InputIterator2, class OutputIterator>

constexpr OutputIterator

merge(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator,

class Compare>

constexpr OutputIterator

merge(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result, Compare comp);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator>

ForwardIterator

merge(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator, class Compare>

ForwardIterator

merge(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result, Compare comp);

template<class BidirectionalIterator>

void inplace_merge(BidirectionalIterator first,

BidirectionalIterator middle,

BidirectionalIterator last);

template<class BidirectionalIterator, class Compare>

void inplace_merge(BidirectionalIterator first,

BidirectionalIterator middle,

BidirectionalIterator last, Compare comp);

template<class ExecutionPolicy, class BidirectionalIterator>

void inplace_merge(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

BidirectionalIterator first,

BidirectionalIterator middle,

BidirectionalIterator last);

template<class ExecutionPolicy, class BidirectionalIterator, class Compare>

void inplace_merge(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

BidirectionalIterator first,

BidirectionalIterator middle,

BidirectionalIterator last, Compare comp);

// \ref{alg.set.operations}, set operations

template<class InputIterator1, class InputIterator2>

constexpr bool includes(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2);

template<class InputIterator1, class InputIterator2, class Compare>

constexpr bool includes(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

Compare comp);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>

bool includes(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class Compare>

bool includes(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

Compare comp);

template<class InputIterator1, class InputIterator2, class OutputIterator>

constexpr OutputIterator

set_union(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>

constexpr OutputIterator

set_union(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result, Compare comp);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator>

ForwardIterator

set_union(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator, class Compare>

ForwardIterator

set_union(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result, Compare comp);

template<class InputIterator1, class InputIterator2, class OutputIterator>

constexpr OutputIterator

set_intersection(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>

constexpr OutputIterator

set_intersection(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result, Compare comp);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator>

ForwardIterator

set_intersection(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator, class Compare>

ForwardIterator

set_intersection(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result, Compare comp);

template<class InputIterator1, class InputIterator2, class OutputIterator>

constexpr OutputIterator

set_difference(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>

constexpr OutputIterator

set_difference(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result, Compare comp);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator>

ForwardIterator

set_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator, class Compare>

ForwardIterator

set_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result, Compare comp);

template<class InputIterator1, class InputIterator2, class OutputIterator>

constexpr OutputIterator

set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result);

template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>

constexpr OutputIterator

set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, InputIterator2 last2,

OutputIterator result, Compare comp);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator>

ForwardIterator

set_symmetric_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,

class ForwardIterator, class Compare>

ForwardIterator

set_symmetric_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

ForwardIterator1 first1, ForwardIterator1 last1,

ForwardIterator2 first2, ForwardIterator2 last2,

ForwardIterator result, Compare comp);

// \ref{alg.heap.operations}, heap operations

template<class RandomAccessIterator>

void push_heap(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void push_heap(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

void pop_heap(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void pop_heap(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

void make_heap(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void make_heap(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

void sort_heap(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

void sort_heap(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class ExecutionPolicy, class RandomAccessIterator>

bool is_heap(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>

bool is_heap(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class RandomAccessIterator>

constexpr RandomAccessIterator

is_heap_until(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>

constexpr RandomAccessIterator

is_heap_until(RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

template<class ExecutionPolicy, class RandomAccessIterator>

RandomAccessIterator

is_heap_until(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last);

template<class ExecutionPolicy, class RandomAccessIterator, class Compare>

RandomAccessIterator

is_heap_until(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}

RandomAccessIterator first, RandomAccessIterator last,

Compare comp);

// \ref{alg.min.max}, minimum and maximum

template<class T> constexpr const T& min(const T& a, const T& b);

template<class T, class Compare>

constexpr const T& min(const T& a, const T& b, Compare comp);

template<class T>

constexpr T min(initializer_list<T> t);

template<class T, class Compare>

constexpr T min(initializer_list<T> t, Compare comp);

template<class T> constexpr const T& max(const T& a, const T& b);

template<class T, class Compare>

constexpr const T& max(const T& a, const T& b, Compare comp);

template<class T>

constexpr T max(initializer_list<T> t);

template<class T, class Compare>

constexpr T max(initializer_list<T> t, Compare comp);

template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);